NEML2 2.0.0
Loading...
Searching...
No Matches
neml2 Namespace Reference

Namespaces

namespace  utils
namespace  jit
namespace  crystallography
namespace  discretization
namespace  linalg
namespace  indexing

Classes

struct  DiagnosticState
struct  Diagnosing
class  DiagnosticsInterface
 Interface for object making diagnostics about common setup errors. More...
class  EnumSelection
 Selection of an enum value from a list of choices. More...
class  EnumSelectionBase
class  Factory
struct  TimedSection
class  HITParser
 A parser is responsible for parsing an input file into a collection of options which can be used by the Factory to manufacture corresponding objects. More...
class  InputFile
 A data structure that holds options of multiple objects. More...
class  LabeledAxis
 A labeled axis is used to associate layout of a tensor with human-interpretable names. More...
class  LabeledAxisAccessor
 The accessor containing all the information needed to access an item in a LabeledAxis. More...
class  MultiEnumSelection
 Selection of multiple enum value from a list of choices. More...
class  NEML2Object
 The base class of all "manufacturable" objects in the NEML2 library. More...
class  Option
class  OptionBase
class  OptionSet
 A custom map-like data structure. The keys are strings, and the values can be nonhomogeneously typed. More...
class  Parser
 A parser is responsible for parsing an input file into a collection of options which can be used by the Factory to manufacture corresponding objects. More...
struct  NEML2ObjectInfo
 Information on a NEML2Object that is registered in the Registry. More...
class  Registry
class  Settings
struct  TensorName
 The name of a tensor object that can be referenced in the input files. More...
struct  TraceWriter
class  TracingInterface
class  FixedSizeWorkGenerator
 Interface for work generators that generate a fixed number of batches, i.e., the total amount of work is known at construction time. More...
class  SimpleMPIScheduler
 A simple MPI scheduler. More...
class  SimpleScheduler
 A very simple scheduler. More...
class  SliceGenerator
class  StaticHybridScheduler
 A scheduler for multiple devices with static priority management. More...
class  TensorLoader
class  ValueMapLoader
class  WorkDispatcher
 The work dispatcher who dispatches work to a worker and reduces the results. More...
class  WorkGenerator
class  WorkScheduler
 Scheduler for work dispatching. More...
class  Driver
 The Driver drives the execution of a NEML2 Model. More...
class  ModelDriver
 A general-purpose driver that does something with a model. More...
class  LDISolidMechanicsDriver
 Large deformation incremental solid mechanics driver. More...
class  SDTSolidMechanicsDriver
 Small deformation total solid mechanics driver. More...
class  SolidMechanicsDriver
 The transient driver specialized for solid mechanics problems. More...
class  TransientDriver
 The driver for a transient initial-value problem. More...
class  Derivative
 Derivative wrapper. More...
class  EquationSystem
 Base class for manufacturable objects under the EquationSystems section. More...
class  LinearSystem
 Definition of a linear system of equations, Au = b. More...
class  NonlinearSystem
 Definition of a nonlinear system of equations, r(u) = 0. More...
struct  SparseTensorList
 Alias for a list of Tensors. More...
class  NEMLException
class  SetupException
class  ParserException
class  FactoryException
class  Diagnosis
 Exception type reserved for diagnostics, so as to not conceptually clash with other exceptions. More...
class  ArrheniusParameter
 A scalar-valued parameter following an Arrhenius type relation. More...
class  BackwardEulerTimeIntegration
class  BilinearInterpolation
 Linearly interpolate the parameter along on a 2D grid. More...
class  TensorBase
 NEML2's enhanced tensor type. More...
class  BufferStore
 Interface for object which can store buffers. More...
class  AvramiErofeevNucleation
 Avrami-Erofeev nucleation model. More...
class  ContractingGeometry
 Contracting geometry model in the context of solid-state reaction kinetics. More...
class  CylindricalChannelGeometry
class  DiffusionLimitedReaction
class  EffectiveVolume
 Update the effective volume of a control mass composite during reaction. More...
class  ReactionMechanism
 Define the mechanism reaction function. More...
class  ComposedModel
class  ConstantParameter
 A parameter that is actually just a constant. More...
class  CopyVariable
 Copy the value of a variable into another variable. More...
class  Data
class  DependencyDefinition
class  DependencyResolver
 The DependencyResolver identifies and resolves the dependencies among a set of objects derived from DependencyDefinition. More...
class  Determinant
 Determinant of a rank two tensor. More...
class  DynamicMean
class  DynamicSum
class  FiniteVolumeAppendBoundaryCondition
 Append a boundary condition value to the intermediate dimension. More...
class  FiniteVolumeGradient
 Prefactor-weighted gradient at cell edges using first-order reconstruction. More...
class  FiniteVolumeUpwindedAdvectiveFlux
 First-order upwind advective flux at cell edges. More...
class  LinearlyInterpolateToCellEdges
 Linearly interpolate cell-centered values to cell edges. More...
class  FischerBurmeister
 Define the Fischer Burmeister Complementary Conditions. More...
class  ForwardEulerTimeIntegration
class  HermiteSmoothStep
class  ImplicitUpdate
class  IncrementToRate
class  InputParameter
 A parameter that is defined by an input variable. More...
class  IntermediateDiff
class  IntermediateMean
class  IntermediateSum
class  Interpolation
 The base class for interpolated variable. More...
class  LinearCombination
class  LinearInterpolation
 Linearly interpolate the parameter along an intermediate axis. More...
class  MixedControlSetup
struct  AssemblyingNonlinearSystem
class  Model
 The base class for all constitutive models. More...
class  ModelNonlinearSystem
 A monolith nonlinear system defined by a Model. More...
struct  NonlinearParameter
 Nonlinear parameter. More...
class  ParameterStore
 Interface for object which can store parameters. More...
class  ParameterToState
 Convert a parameter to a state variable. More...
class  CrackGeometricFunction
class  CrackGeometricFunctionAT1
class  CrackGeometricFunctionAT2
class  DegradationFunction
class  LinearIsotropicStrainEnergyDensity
class  PowerDegradationFunction
class  RationalDegradationFunction
class  StrainEnergyDensity
class  AdvectiveStress
 Variational advective stress associated with swelling induced volume change. More...
class  BrooksCoreyCapillaryPressure
 Define the Brooks-Corey correlation for capillary pressure. More...
class  CapillaryPressure
 Base class for capillary pressure models in porous flow. More...
class  EffectiveSaturation
 Define the effective saturation. More...
class  ExponentialLawPermeability
class  KozenyCarmanPermeability
 The Kozeny-Carman porosity-permeability relation. More...
class  PorosityPermeabilityRelation
 Base class for the porosity - permeability relations. More...
class  PowerLawPermeability
 power law porosity-permeability relation. More...
class  VanGenuchtenCapillaryPressure
 van Genuchten correlation for capillary pressure More...
class  R2Multiplication
 Multiplication of two R2 variables. More...
class  R2toSR2
 Get the symmetric part of a full rank two tensor. More...
class  R2toWR2
 Get the skew symmetric part of a full rank two tensor. More...
class  Reduction
class  RotationMatrix
 Convert a Rodrigues vector (Rot) to a second order tensor (R2). More...
class  ScalarMultiplication
 Define the multiplication of arbitrary number of state variables. More...
class  ScalarToDiagonalSR2
 Create a diagonal symmetric rank 2 tensor with values filled by a scalar. More...
class  AssociativeIsotropicPlasticHardening
class  AssociativeJ2FlowDirection
 The plastic flow direction assuming an associative J2 flow. More...
class  AssociativeKinematicPlasticHardening
class  AssociativePlasticFlow
class  ChabochePlasticHardening
class  DislocationObstacleStrengthMap
 Dislocation density -> strength as in Taylor \( \tau_i = \tau_{const} + \alpha \mu b \sqrt{\rho_i} \). More...
class  ElasticStrainRate
 Calculate the elastic strain rate from crystal model kinematics. More...
class  FixOrientation
 Swap orientation plane when the singularity at \( 2 \pi \) is met with the modified Rodrigues vector. More...
class  LinearSingleSlipHardeningRule
 Linear slip hardening of the type \(\dot{\bar{\tau}} = \theta \sum \left|\dot{\gamma}_i \right|\). More...
class  OrientationRate
 Calculate the orientation rate from the crystal model kinetics. More...
class  PerSlipForestDislocationEvolution
 Standard forest hardening model, per slip system dislocation density. More...
class  PlasticDeformationRate
 Plastic deformation rate with the default kinetics. More...
class  PlasticSpatialVelocityGradient
 Plastic spatial velocity gradient with the default kinetics. More...
class  PlasticVorticity
 Calculate the plastic vorticity with the default crystal kinetics. More...
class  PowerLawSlipRule
 Power law slip rate of the form \(\dot{\gamma}_i = \dot{\gamma}_0 \left| \frac{\tau_i}{\tau_{h,i}} \right| ^ {n-1} \frac{\tau_i}{\tau_{h,i}} \). More...
class  ResolvedShear
 Calculate the resolved shears. More...
class  SingleSlipHardeningRule
 Any slip rule where all systems share the same strength. More...
class  SingleSlipStrengthMap
 A map between the internal variables and the slip strength, for the case where all systems share the same strength. More...
class  SlipRule
 Parent class of slip rules, mapping from resolved shear and internal state to slip rates. More...
class  SlipStrengthMap
 Parent class of maps between internal variables and the slip system strengths. More...
class  SumSlipRates
 A helper model to calculate the sum of the absolute value of the slip rates. More...
class  VoceSingleSlipHardeningRule
 Voce slip hardening when all slip systems share the same hardening value, \(\dot{\bar{\tau}} = \theta_0 \left(1 - \frac{\bar{\tau}}{\tau_{sat}} \right) \sum \left|\dot{\gamma}_i \right|\). More...
class  Eigenstrain
class  AnisotropicElasticity
class  CubicElasticityConverter
 Converter for linearized elastic constants assuming cubic symmetry. More...
class  CubicElasticityTensor
 Define an cubic symmetry elasticity tensor in various ways. More...
class  Elasticity
class  ElasticityConverter
 Base class for converters responsible for converting between different parameterizations of the linear elasticity tensor in different symmetry groups. More...
class  ElasticityInterface
 Interface for objects defining elasticity tensors in terms of other parameters. More...
class  GeneralElasticity
class  GreenLagrangeStrain
class  IsotropicElasticityConverter
 Converter for linearized elastic constants assuming isotropic symmetry. More...
class  IsotropicElasticityTensor
 Define an isotropoic elasticity tensor in various ways. More...
class  LinearIsotropicElasticity
class  FlowRule
class  FredrickArmstrongPlasticHardening
class  GTNYieldFunction
class  GursonCavitation
class  IsotropicHardening
class  IsotropicHardeningStaticRecovery
class  IsotropicMandelStress
class  KinematicHardening
class  KinematicHardeningStaticRecovery
class  KocksMeckingActivationEnergy
class  KocksMeckingFlowSwitch
class  KocksMeckingFlowViscosity
 A scalar-valued parameter defined by (mu0 - D/(exp(T0/T)-1)) * exp(_C). More...
class  KocksMeckingIntercept
 A scalar-valued parameter defined by (C-B) / A. More...
class  KocksMeckingRateSensitivity
 A scalar-valued parameter defined by (mu0 - D/(exp(T0/T)-1)) * exp(_C). More...
class  KocksMeckingYieldStress
 A scalar-valued parameter defined by (mu0 - D/(exp(T0/T)-1)) * exp(_C). More...
class  LinearIsotropicElasticJ2TrialStressUpdate
 Update the trial stress under the assumptions of J2 plasticity and isotropic linear elasticity. More...
class  LinearIsotropicHardening
 Simple linear map between equivalent strain and isotropic hardening. More...
class  LinearKinematicHardening
 Simple linear map between equivalent strain and hardening. More...
class  MandelStress
class  Normality
class  OlevskySinteringStress
class  PerzynaPlasticFlowRate
class  PhaseTransformationEigenstrain
 Define the phase transformation eigenstrain. More...
class  PlasticFlowRate
class  PowerLawIsotropicHardeningStaticRecovery
class  PowerLawKinematicHardeningStaticRecovery
class  RateIndependentPlasticFlowConstraint
class  SlopeSaturationVoceIsotropicHardening
class  SwellingAndPhaseChangeDeformationJacobian
class  ThermalDeformationJacobian
class  ThermalEigenstrain
class  TwoStageThermalAnnealing
class  VoceIsotropicHardening
class  VolumeAdjustDeformationGradient
 Calculate the volume-adjusted deformation gradient. More...
class  VolumeChangeEigenstrain
 Define the volume change eigenstrain. More...
class  YieldFunction
class  SR2Invariant
class  SR2toR2
 Convert symmetric rank two tensor to full. More...
class  SymmetricHermiteInterpolation
struct  TracerPrivilege
 A passkey to allow trusted classes to perform raw assignment to variables and parameters. More...
class  Variable
 Concrete definition of a variable. More...
class  VariableBase
 Base class of variable. More...
class  VariableRate
class  VariableStore
class  WR2ExplicitExponentialTimeIntegration
 Explicit exponential time integration for rotations. More...
class  WR2ImplicitExponentialTimeIntegration
 Implicit exponential time integration for rotations. More...
class  DenseLU
class  LinearSolver
 The linear solver solves a linear system of equations. More...
class  Newton
 The nonlinear solver solves a nonlinear system of equations. More...
class  NewtonWithLineSearch
 The nonlinear solver solves a nonlinear system of equations. More...
class  NonlinearSolver
 The nonlinear solver solves a nonlinear system of equations. More...
class  Solver
 The solver solves a system of equations. More...
struct  concat_seq
struct  concat_seq< std::integer_sequence< Size, A... >, std::integer_sequence< Size, B... > >
struct  DTensorBase
struct  DTensorBase< Derived, std::integer_sequence< Size, S... > >
class  DTensor
 Abstract representation of the derivative of a primitive tensor with respect to another primitive tensor. More...
struct  imap_t
struct  imap_t< Scalar >
struct  imap_t< Vec >
struct  imap_t< R2 >
struct  imap_t< SR2 >
class  MillerIndex
 Represention of a crystal direction or plane a Miller Index. More...
class  PrimitiveTensor
 PrimitiveTensor inherits from TensorBase and additionally templates on the base shape. More...
class  Quaternion
 Quaternion. More...
class  VecBase
 Base class 3-vector. More...
class  R2
 Base class for second order tensor. More...
class  R3
 Third order tensor without symmetry. More...
class  R4
 Fourth order tensor without symmetry. More...
class  Rot
 Rotation stored as modified Rodrigues parameters. More...
class  Scalar
 Scalar. More...
class  SFFR4
 The fourth order tensor with minor symmetry in the 1st and 2nd dimensions. More...
class  SFR3
 The third order tensor with symmetry in the first two dimensions. More...
class  SR2
 The symmetric second order tensor. More...
class  SSR4
 The symmetric fourth order tensor, with symmetry in the first two dimensionss as well as in the last two dimensions. More...
class  SWR4
 The symmetric fourth order tensor, with symmetry in the first two dimensionss and skew-symmetry in the second two. More...
class  Tensor
struct  TensorCache
struct  TensorTypeEnum
struct  TensorTypeEnum< Vec >
struct  TensorTypeEnum< Rot >
struct  TensorTypeEnum< WR2 >
struct  TensorTypeEnum< R2 >
struct  TensorTypeEnum< SR2 >
struct  TensorTypeEnum< R3 >
struct  TensorTypeEnum< SFR3 >
struct  TensorTypeEnum< R4 >
struct  TensorTypeEnum< SFFR4 >
struct  TensorTypeEnum< WFFR4 >
struct  TensorTypeEnum< SSR4 >
struct  TensorTypeEnum< SWR4 >
struct  TensorTypeEnum< WSR4 >
struct  TensorTypeEnum< WWR4 >
struct  TensorTypeEnum< Quaternion >
struct  TensorTypeEnum< MillerIndex >
struct  TensorTypeEnum< Tensor >
struct  TensorTypeEnum< Scalar >
class  TensorValueBase
 The base class to allow us to set up a polymorphic container of Tensors. The concrete definitions will be templated on the actual tensor type. More...
class  TensorValue
 Concrete definition of tensor value. More...
struct  TraceableSize
 Traceable size. More...
struct  TraceableTensorShape
 Traceable tensor shape. More...
class  Transformable
 Mixin class for things that can be transformed by a symmetry operator. More...
class  Vec
 3-vector. More...
class  WFFR4
 The fourth order tensor with skew symmetry in the first two dimensions. More...
class  WR2
 A skew-symmetric second order tensor, represented as an axial vector. More...
class  WSR4
 The symmetric fourth order tensor, with skew symmetry in the first two dimensionss and symmetry in the second two. More...
class  WWR4
 The symmetric fourth order tensor, with skew symmetry in the first two dimensions and last two dimensions. More...
class  CenterTensorTmpl
 Compute interval centers along an intermediate dimension. More...
class  CSVPrimitiveTensor
 Create a primitive tensor by reading values from a csv file. More...
class  CSVReader
 An interface class for reading CSV files. More...
class  DifferenceTensorTmpl
 Compute finite differences along an intermediate dimension. More...
class  FactoryMethodBase
 Create an empty tensor of type T from the input file. More...
class  FillR2
 Create a filled R2 from the input file. More...
class  FillRot
 Create a filled R2 from the input file. More...
class  FillSR2
 Create a filled SR2 from the input file. More...
class  FillWR2
 Create a filled WR2 from the input file. More...
class  FromTorchScript
 Read the tensors provided by a torch script file. More...
class  FullTensorTmpl
 Create a full tensor of type T from the input file. More...
class  GaussianTensorTmpl
 Create a Gaussian tensor evaluated at provided points. More...
class  IdentityTensor
 Create an identity Tensor from the input file. More...
class  LinspaceTensorTmpl
 Create a linspace tensor of type T from the input file. More...
class  LogspaceTensorTmpl
 Create a logspace tensor of type T from the input file. More...
class  MultiColumnCSVScalar
class  Orientation
 Create batch of rotations, with various methods. More...
class  RandomTensorImpl
 Create a random tensor of type T from the input file. More...
class  SymmetryFromOrbifold
 Provide the correct symmetry operators for a given crystal class. More...
class  UserTensorTmpl
 Create raw tensor of type T from the input file. More...
class  UserTensorBase

Typedefs

using VariableName = LabeledAxisAccessor
using SubaxisName = LabeledAxisAccessor
using BuildPtr = std::shared_ptr<NEML2Object> (*)(const OptionSet & options)
using json = nlohmann::json
using ATensor = at::Tensor
using CScalar = c10::Scalar
template<typename T, unsigned N>
using SmallVector = c10::SmallVector<T, N>
template<typename T>
using ArrayRef = c10::ArrayRef<T>
template<typename T>
using OptionalArrayRef = c10::OptionalArrayRef<T>
using TensorOptions = c10::TensorOptions
using Dtype = c10::ScalarType
using DeviceIndex = c10::DeviceIndex
using Device = c10::Device
using Size = int64_t
using TensorShape = c10::SmallVector<Size, 8>
using TensorShapeRef = c10::ArrayRef<Size>
typedef BackwardEulerTimeIntegration< ScalarScalarBackwardEulerTimeIntegration
typedef BackwardEulerTimeIntegration< VecVecBackwardEulerTimeIntegration
typedef BackwardEulerTimeIntegration< SR2SR2BackwardEulerTimeIntegration
typedef BackwardEulerTimeIntegration< R2R2BackwardEulerTimeIntegration
using ValueMap = std::map<LabeledAxisAccessor, Tensor>
using DerivMap = std::map<LabeledAxisAccessor, ValueMap>
using SecDerivMap = std::map<LabeledAxisAccessor, DerivMap>
template<class Seq1, class Seq2>
using concat_seq_t = typename concat_seq<Seq1, Seq2>::type
template<class Derived, class Seq>
using DTensorBase_t = typename DTensorBase<Derived, Seq>::type
using TensorDataContainer = torch::detail::TensorDataContainer
using TensorList = c10::ArrayRef<neml2::Tensor>

Enumerations

enum class  FType : int8_t {
  NONE = 0 , INPUT = 1 << 0 , OUTPUT = 1 << 1 , PARAMETER = 1 << 2 ,
  BUFFER = 1 << 3
}
 Role in a function definition. More...
enum class  ElasticConstant : std::uint8_t {
  INVALID = 0 , LAME_LAMBDA = 1 , BULK_MODULUS = 2 , SHEAR_MODULUS = 3 ,
  YOUNGS_MODULUS = 4 , POISSONS_RATIO = 5 , P_WAVE_MODULUS = 6 , CUBIC_C1 = 7 ,
  CUBIC_C2 = 8 , CUBIC_C3 = 9
}
enum class  TensorType : int8_t {
  kVec , kRot , kWR2 , kR2 ,
  kScalar , kSR2 , kR3 , kSFR3 ,
  kR4 , kSFFR4 , kWFFR4 , kSSR4 ,
  kSWR4 , kWSR4 , kWWR4 , kQuaternion ,
  kMillerIndex , kTensor , kUknown
}

Functions

DiagnosticStatecurrent_diagnostic_state ()
 Get the current diagnostic state.
std::vector< Diagnosis > & current_diagnoses ()
 Get the current diagnoses.
std::vector< Diagnosisdiagnose (const DiagnosticsInterface &)
 A helper function to diagnose common setup errors.
void diagnose_and_throw (const DiagnosticsInterface &)
 A helper function to diagnose common setup errors and throw an exception if any errors are found.
template<typename... Args>
void diagnostic_assert (bool, Args &&...)
 Helper assertion function for diagnostics.
template<typename... Args>
void diagnostic_assert (bool assertion, Args &&... args)
std::ostream & operator<< (std::ostream &, const EnumSelection &)
std::stringstream & operator>> (std::stringstream &, EnumSelection &)
std::map< std::string, std::map< std::string, unsigned long > > & timed_sections ()
std::ostream & operator<< (std::ostream &os, const InputFile &p)
std::ostream & operator<< (std::ostream &os, const LabeledAxis &axis)
bool operator== (const LabeledAxis &a, const LabeledAxis &b)
bool operator!= (const LabeledAxis &a, const LabeledAxis &b)
std::vector< std::string > reserved_subaxis_names ()
bool operator== (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b)
 Compare for equality between two LabeledAxisAccessor.
bool operator!= (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b)
 Compare for equality between two LabeledAxisAccessor.
bool operator< (const LabeledAxisAccessor &a, const LabeledAxisAccessor &b)
 The (strict) smaller than operator is created so as to use LabeledAxisAccessor in sorted data structures.
std::ostream & operator<< (std::ostream &os, const LabeledAxisAccessor &accessor)
 Serialize the accessor into a string. The format is simply the concatenation of all the item names delimited by "/".
std::ostream & operator<< (std::ostream &, const MultiEnumSelection &)
std::stringstream & operator>> (std::stringstream &, MultiEnumSelection &)
std::ostream & operator<< (std::ostream &, const OptionBase &)
bool options_compatible (const OptionSet &opts, const OptionSet &additional_opts)
std::ostream & operator<< (std::ostream &os, const OptionSet &p)
template<typename T>
std::stringstream & operator>> (std::stringstream &ss, TensorName< T > &t)
 Stream into a TensorName (used by Parsers to extract input options).
template<typename T>
std::ostream & operator<< (std::ostream &os, const TensorName< T > &t)
 Stream out a TensorName (used for printing OptionSet).
std::unordered_map< std::string, std::unique_ptr< TraceWriter > > & event_trace_writers ()
 All trace writers.
DerivMap derivmap_cat_reduce (std::vector< DerivMap > &&results, Size dynamic_dim)
 Concatenate the tensors in the DerivMap along the batch dimension.
DerivMap derivmap_move_device (DerivMap &&x, Device device)
 Move all tensors in a DerivMap to a device.
DerivMap derivmap_no_operation (DerivMap &&x)
 No operation.
ValueMap valuemap_cat_reduce (const std::vector< ValueMap > &results, Size dynamic_dim)
 Concatenate the tensors in the ValueMap along the batch dimension.
ValueMap valuemap_move_device (ValueMap &&x, Device device)
 Move all tensors in a ValueMap to a device.
ValueMap valuemap_no_operation (ValueMap &&x)
 No operation.
Tensor pop_intrsc_intmd_dim (const Tensor &t, Size dim)
 Move the trailing dim intermediate dimensions to the base.
Tensor push_intrsc_intmd_dim (const Tensor &t, Size dim)
 Move the leading dim base dimensions to intermediate dimensions.
Tensor pop_intrsc_intmd_dim (const Derivative< 1 > &deriv)
template<std::size_t N>
Tensor pop_intrsc_intmd_dim (const Tensor &from, const std::array< std::size_t, N > &intrsc_intmd_dims, const std::array< TensorShape, N > &base_shapes, const std::string &debug_name="<anonymous>")
template<std::size_t N>
Tensor push_intrsc_intmd_dim (const Tensor &from, const std::array< std::size_t, N > &intrsc_intmd_dims, const std::array< TensorShape, N > &base_shapes, const std::string &debug_name="<anonymous>")
template<std::size_t N>
Tensor from_assembly (const Tensor &from, const std::array< TensorShape, N > &intmd_shapes, const std::array< TensorShape, N > &base_shapes)
template<std::size_t N>
Tensor to_assembly (const Tensor &from, const std::array< TensorShape, N > &intmd_shapes, const std::array< TensorShape, N > &base_shapes)
SparseTensorList disassemble (const Tensor &, const std::optional< std::vector< TensorShape > > &intmd_shapes, const std::vector< TensorShape > &base_shapes)
Tensor assemble (const SparseTensorList &, const std::optional< std::vector< TensorShape > > &intmd_shapes, const std::vector< TensorShape > &base_shapes)
SparseTensorList disassemble (const Tensor &, const std::optional< std::vector< TensorShape > > &row_intmd_shapes, const std::optional< std::vector< TensorShape > > &col_intmd_shapes, const std::vector< TensorShape > &row_base_shapes, const std::vector< TensorShape > &col_base_shapes)
Tensor assemble (const SparseTensorList &, const std::optional< std::vector< TensorShape > > &row_intmd_shapes, const std::optional< std::vector< TensorShape > > &col_intmd_shapes, const std::vector< TensorShape > &row_base_shapes, const std::vector< TensorShape > &col_base_shapes)
template<typename... Args>
void neml_assert (bool assertion, Args &&... args)
template<typename... Args>
void neml_assert_dbg (bool assertion, Args &&... args)
double machine_precision (Dtype)
std::ostream & operator<< (std::ostream &os, FType f)
std::tuple< Scalar, Scalar, Scalarparametric_coordinates (const Scalar &X, const Scalar &x)
template<typename T>
apply_mask (const T &a, const Scalar &m, std::size_t mdim)
bool & currently_assembling_nonlinear_system ()
std::ostream & operator<< (std::ostream &os, const Model &model)
std::string name (ElasticConstant p)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator+ (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator- (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator* (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator/ (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator> (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator< (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator>= (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator<= (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator&& (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator|| (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator== (const T1 &a, const T2 &b)
template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator!= (const T1 &a, const T2 &b)
ValueMap bind (const std::vector< VariableName > &, const std::vector< Tensor > &)
 Bind a vector of tensors to variable names.
void force_link_runtime ()
 Force linking of all runtime components.
std::unique_ptr< Factoryload_input (const std::filesystem::path &path, const std::string &additional_input="")
 A convenient function to parse all options from an input file.
std::shared_ptr< Modelload_model (const std::filesystem::path &path, const std::string &mname)
 A convenient function to load an input file and get a model.
template<class... T>
void neml_assert_broadcastable (const T &... tensors)
template<class... T>
void neml_assert_dynamic_broadcastable (const T &... tensors)
template<class... T>
void neml_assert_intmd_broadcastable (const T &... tensors)
template<class... T>
void neml_assert_batch_broadcastable (const T &... tensors)
template<class... T>
void neml_assert_base_broadcastable (const T &... tensors)
template<class... T>
void neml_assert_static_broadcastable (const T &... tensors)
template<std::size_t N>
std::string derivative_name (const std::string &var_name, const std::array< std::string, N > &arg_names)
 Pretty print derivative names.
template<std::size_t N>
Tensor fullify (const Tensor &t, Size iid, std::array< TensorShape, N > iiss)
Vec abs (const Vec &a)
Rot abs (const Rot &a)
WR2 abs (const WR2 &a)
R2 abs (const R2 &a)
SR2 abs (const SR2 &a)
R3 abs (const R3 &a)
SFR3 abs (const SFR3 &a)
R4 abs (const R4 &a)
SFFR4 abs (const SFFR4 &a)
WFFR4 abs (const WFFR4 &a)
SSR4 abs (const SSR4 &a)
SWR4 abs (const SWR4 &a)
WSR4 abs (const WSR4 &a)
WWR4 abs (const WWR4 &a)
Quaternion abs (const Quaternion &a)
MillerIndex abs (const MillerIndex &a)
Tensor abs (const Tensor &a)
Scalar abs (const Scalar &a)
Vec acos (const Vec &a)
Rot acos (const Rot &a)
WR2 acos (const WR2 &a)
R2 acos (const R2 &a)
SR2 acos (const SR2 &a)
R3 acos (const R3 &a)
SFR3 acos (const SFR3 &a)
R4 acos (const R4 &a)
SFFR4 acos (const SFFR4 &a)
WFFR4 acos (const WFFR4 &a)
SSR4 acos (const SSR4 &a)
SWR4 acos (const SWR4 &a)
WSR4 acos (const WSR4 &a)
WWR4 acos (const WWR4 &a)
Quaternion acos (const Quaternion &a)
MillerIndex acos (const MillerIndex &a)
Tensor acos (const Tensor &a)
Scalar acos (const Scalar &a)
Vec dynamic_argmax (const Vec &a, Size dim)
Vec intmd_argmax (const Vec &a, Size dim)
Vec base_argmax (const Vec &a, Size dim)
Rot dynamic_argmax (const Rot &a, Size dim)
Rot intmd_argmax (const Rot &a, Size dim)
Rot base_argmax (const Rot &a, Size dim)
WR2 dynamic_argmax (const WR2 &a, Size dim)
WR2 intmd_argmax (const WR2 &a, Size dim)
WR2 base_argmax (const WR2 &a, Size dim)
R2 dynamic_argmax (const R2 &a, Size dim)
R2 intmd_argmax (const R2 &a, Size dim)
R2 base_argmax (const R2 &a, Size dim)
SR2 dynamic_argmax (const SR2 &a, Size dim)
SR2 intmd_argmax (const SR2 &a, Size dim)
SR2 base_argmax (const SR2 &a, Size dim)
R3 dynamic_argmax (const R3 &a, Size dim)
R3 intmd_argmax (const R3 &a, Size dim)
R3 base_argmax (const R3 &a, Size dim)
SFR3 dynamic_argmax (const SFR3 &a, Size dim)
SFR3 intmd_argmax (const SFR3 &a, Size dim)
SFR3 base_argmax (const SFR3 &a, Size dim)
R4 dynamic_argmax (const R4 &a, Size dim)
R4 intmd_argmax (const R4 &a, Size dim)
R4 base_argmax (const R4 &a, Size dim)
SFFR4 dynamic_argmax (const SFFR4 &a, Size dim)
SFFR4 intmd_argmax (const SFFR4 &a, Size dim)
SFFR4 base_argmax (const SFFR4 &a, Size dim)
WFFR4 dynamic_argmax (const WFFR4 &a, Size dim)
WFFR4 intmd_argmax (const WFFR4 &a, Size dim)
WFFR4 base_argmax (const WFFR4 &a, Size dim)
SSR4 dynamic_argmax (const SSR4 &a, Size dim)
SSR4 intmd_argmax (const SSR4 &a, Size dim)
SSR4 base_argmax (const SSR4 &a, Size dim)
SWR4 dynamic_argmax (const SWR4 &a, Size dim)
SWR4 intmd_argmax (const SWR4 &a, Size dim)
SWR4 base_argmax (const SWR4 &a, Size dim)
WSR4 dynamic_argmax (const WSR4 &a, Size dim)
WSR4 intmd_argmax (const WSR4 &a, Size dim)
WSR4 base_argmax (const WSR4 &a, Size dim)
WWR4 dynamic_argmax (const WWR4 &a, Size dim)
WWR4 intmd_argmax (const WWR4 &a, Size dim)
WWR4 base_argmax (const WWR4 &a, Size dim)
Quaternion dynamic_argmax (const Quaternion &a, Size dim)
Quaternion intmd_argmax (const Quaternion &a, Size dim)
Quaternion base_argmax (const Quaternion &a, Size dim)
MillerIndex dynamic_argmax (const MillerIndex &a, Size dim)
MillerIndex intmd_argmax (const MillerIndex &a, Size dim)
MillerIndex base_argmax (const MillerIndex &a, Size dim)
Tensor dynamic_argmax (const Tensor &a, Size dim)
Tensor intmd_argmax (const Tensor &a, Size dim)
Tensor base_argmax (const Tensor &a, Size dim)
Scalar dynamic_argmax (const Scalar &a, Size dim)
Scalar intmd_argmax (const Scalar &a, Size dim)
Scalar base_argmax (const Scalar &a, Size dim)
Vec dynamic_argmin (const Vec &a, Size dim)
Vec intmd_argmin (const Vec &a, Size dim)
Vec base_argmin (const Vec &a, Size dim)
Rot dynamic_argmin (const Rot &a, Size dim)
Rot intmd_argmin (const Rot &a, Size dim)
Rot base_argmin (const Rot &a, Size dim)
WR2 dynamic_argmin (const WR2 &a, Size dim)
WR2 intmd_argmin (const WR2 &a, Size dim)
WR2 base_argmin (const WR2 &a, Size dim)
R2 dynamic_argmin (const R2 &a, Size dim)
R2 intmd_argmin (const R2 &a, Size dim)
R2 base_argmin (const R2 &a, Size dim)
SR2 dynamic_argmin (const SR2 &a, Size dim)
SR2 intmd_argmin (const SR2 &a, Size dim)
SR2 base_argmin (const SR2 &a, Size dim)
R3 dynamic_argmin (const R3 &a, Size dim)
R3 intmd_argmin (const R3 &a, Size dim)
R3 base_argmin (const R3 &a, Size dim)
SFR3 dynamic_argmin (const SFR3 &a, Size dim)
SFR3 intmd_argmin (const SFR3 &a, Size dim)
SFR3 base_argmin (const SFR3 &a, Size dim)
R4 dynamic_argmin (const R4 &a, Size dim)
R4 intmd_argmin (const R4 &a, Size dim)
R4 base_argmin (const R4 &a, Size dim)
SFFR4 dynamic_argmin (const SFFR4 &a, Size dim)
SFFR4 intmd_argmin (const SFFR4 &a, Size dim)
SFFR4 base_argmin (const SFFR4 &a, Size dim)
WFFR4 dynamic_argmin (const WFFR4 &a, Size dim)
WFFR4 intmd_argmin (const WFFR4 &a, Size dim)
WFFR4 base_argmin (const WFFR4 &a, Size dim)
SSR4 dynamic_argmin (const SSR4 &a, Size dim)
SSR4 intmd_argmin (const SSR4 &a, Size dim)
SSR4 base_argmin (const SSR4 &a, Size dim)
SWR4 dynamic_argmin (const SWR4 &a, Size dim)
SWR4 intmd_argmin (const SWR4 &a, Size dim)
SWR4 base_argmin (const SWR4 &a, Size dim)
WSR4 dynamic_argmin (const WSR4 &a, Size dim)
WSR4 intmd_argmin (const WSR4 &a, Size dim)
WSR4 base_argmin (const WSR4 &a, Size dim)
WWR4 dynamic_argmin (const WWR4 &a, Size dim)
WWR4 intmd_argmin (const WWR4 &a, Size dim)
WWR4 base_argmin (const WWR4 &a, Size dim)
Quaternion dynamic_argmin (const Quaternion &a, Size dim)
Quaternion intmd_argmin (const Quaternion &a, Size dim)
Quaternion base_argmin (const Quaternion &a, Size dim)
MillerIndex dynamic_argmin (const MillerIndex &a, Size dim)
MillerIndex intmd_argmin (const MillerIndex &a, Size dim)
MillerIndex base_argmin (const MillerIndex &a, Size dim)
Tensor dynamic_argmin (const Tensor &a, Size dim)
Tensor intmd_argmin (const Tensor &a, Size dim)
Tensor base_argmin (const Tensor &a, Size dim)
Scalar dynamic_argmin (const Scalar &a, Size dim)
Scalar intmd_argmin (const Scalar &a, Size dim)
Scalar base_argmin (const Scalar &a, Size dim)
Vec asin (const Vec &a)
Rot asin (const Rot &a)
WR2 asin (const WR2 &a)
R2 asin (const R2 &a)
SR2 asin (const SR2 &a)
R3 asin (const R3 &a)
SFR3 asin (const SFR3 &a)
R4 asin (const R4 &a)
SFFR4 asin (const SFFR4 &a)
WFFR4 asin (const WFFR4 &a)
SSR4 asin (const SSR4 &a)
SWR4 asin (const SWR4 &a)
WSR4 asin (const WSR4 &a)
WWR4 asin (const WWR4 &a)
Quaternion asin (const Quaternion &a)
MillerIndex asin (const MillerIndex &a)
Tensor asin (const Tensor &a)
Scalar asin (const Scalar &a)
Vec atan (const Vec &a)
Rot atan (const Rot &a)
WR2 atan (const WR2 &a)
R2 atan (const R2 &a)
SR2 atan (const SR2 &a)
R3 atan (const R3 &a)
SFR3 atan (const SFR3 &a)
R4 atan (const R4 &a)
SFFR4 atan (const SFFR4 &a)
WFFR4 atan (const WFFR4 &a)
SSR4 atan (const SSR4 &a)
SWR4 atan (const SWR4 &a)
WSR4 atan (const WSR4 &a)
WWR4 atan (const WWR4 &a)
Quaternion atan (const Quaternion &a)
MillerIndex atan (const MillerIndex &a)
Tensor atan (const Tensor &a)
Scalar atan (const Scalar &a)
Vec atan2 (const Vec &a, const Vec &b)
Rot atan2 (const Rot &a, const Rot &b)
WR2 atan2 (const WR2 &a, const WR2 &b)
R2 atan2 (const R2 &a, const R2 &b)
SR2 atan2 (const SR2 &a, const SR2 &b)
R3 atan2 (const R3 &a, const R3 &b)
SFR3 atan2 (const SFR3 &a, const SFR3 &b)
R4 atan2 (const R4 &a, const R4 &b)
SFFR4 atan2 (const SFFR4 &a, const SFFR4 &b)
WFFR4 atan2 (const WFFR4 &a, const WFFR4 &b)
SSR4 atan2 (const SSR4 &a, const SSR4 &b)
SWR4 atan2 (const SWR4 &a, const SWR4 &b)
WSR4 atan2 (const WSR4 &a, const WSR4 &b)
WWR4 atan2 (const WWR4 &a, const WWR4 &b)
Quaternion atan2 (const Quaternion &a, const Quaternion &b)
MillerIndex atan2 (const MillerIndex &a, const MillerIndex &b)
Tensor atan2 (const Tensor &a, const Tensor &b)
Scalar atan2 (const Scalar &a, const Scalar &b)
Vec dynamic_cat (const std::vector< Vec > &tensors, Size d=0)
Vec dynamic_cat (const std::initializer_list< Vec > &tensors, Size d=0)
Vec intmd_cat (const std::vector< Vec > &tensors, Size d=0)
Vec intmd_cat (const std::initializer_list< Vec > &tensors, Size d=0)
Rot dynamic_cat (const std::vector< Rot > &tensors, Size d=0)
Rot dynamic_cat (const std::initializer_list< Rot > &tensors, Size d=0)
Rot intmd_cat (const std::vector< Rot > &tensors, Size d=0)
Rot intmd_cat (const std::initializer_list< Rot > &tensors, Size d=0)
WR2 dynamic_cat (const std::vector< WR2 > &tensors, Size d=0)
WR2 dynamic_cat (const std::initializer_list< WR2 > &tensors, Size d=0)
WR2 intmd_cat (const std::vector< WR2 > &tensors, Size d=0)
WR2 intmd_cat (const std::initializer_list< WR2 > &tensors, Size d=0)
R2 dynamic_cat (const std::vector< R2 > &tensors, Size d=0)
R2 dynamic_cat (const std::initializer_list< R2 > &tensors, Size d=0)
R2 intmd_cat (const std::vector< R2 > &tensors, Size d=0)
R2 intmd_cat (const std::initializer_list< R2 > &tensors, Size d=0)
SR2 dynamic_cat (const std::vector< SR2 > &tensors, Size d=0)
SR2 dynamic_cat (const std::initializer_list< SR2 > &tensors, Size d=0)
SR2 intmd_cat (const std::vector< SR2 > &tensors, Size d=0)
SR2 intmd_cat (const std::initializer_list< SR2 > &tensors, Size d=0)
R3 dynamic_cat (const std::vector< R3 > &tensors, Size d=0)
R3 dynamic_cat (const std::initializer_list< R3 > &tensors, Size d=0)
R3 intmd_cat (const std::vector< R3 > &tensors, Size d=0)
R3 intmd_cat (const std::initializer_list< R3 > &tensors, Size d=0)
SFR3 dynamic_cat (const std::vector< SFR3 > &tensors, Size d=0)
SFR3 dynamic_cat (const std::initializer_list< SFR3 > &tensors, Size d=0)
SFR3 intmd_cat (const std::vector< SFR3 > &tensors, Size d=0)
SFR3 intmd_cat (const std::initializer_list< SFR3 > &tensors, Size d=0)
R4 dynamic_cat (const std::vector< R4 > &tensors, Size d=0)
R4 dynamic_cat (const std::initializer_list< R4 > &tensors, Size d=0)
R4 intmd_cat (const std::vector< R4 > &tensors, Size d=0)
R4 intmd_cat (const std::initializer_list< R4 > &tensors, Size d=0)
SFFR4 dynamic_cat (const std::vector< SFFR4 > &tensors, Size d=0)
SFFR4 dynamic_cat (const std::initializer_list< SFFR4 > &tensors, Size d=0)
SFFR4 intmd_cat (const std::vector< SFFR4 > &tensors, Size d=0)
SFFR4 intmd_cat (const std::initializer_list< SFFR4 > &tensors, Size d=0)
WFFR4 dynamic_cat (const std::vector< WFFR4 > &tensors, Size d=0)
WFFR4 dynamic_cat (const std::initializer_list< WFFR4 > &tensors, Size d=0)
WFFR4 intmd_cat (const std::vector< WFFR4 > &tensors, Size d=0)
WFFR4 intmd_cat (const std::initializer_list< WFFR4 > &tensors, Size d=0)
SSR4 dynamic_cat (const std::vector< SSR4 > &tensors, Size d=0)
SSR4 dynamic_cat (const std::initializer_list< SSR4 > &tensors, Size d=0)
SSR4 intmd_cat (const std::vector< SSR4 > &tensors, Size d=0)
SSR4 intmd_cat (const std::initializer_list< SSR4 > &tensors, Size d=0)
SWR4 dynamic_cat (const std::vector< SWR4 > &tensors, Size d=0)
SWR4 dynamic_cat (const std::initializer_list< SWR4 > &tensors, Size d=0)
SWR4 intmd_cat (const std::vector< SWR4 > &tensors, Size d=0)
SWR4 intmd_cat (const std::initializer_list< SWR4 > &tensors, Size d=0)
WSR4 dynamic_cat (const std::vector< WSR4 > &tensors, Size d=0)
WSR4 dynamic_cat (const std::initializer_list< WSR4 > &tensors, Size d=0)
WSR4 intmd_cat (const std::vector< WSR4 > &tensors, Size d=0)
WSR4 intmd_cat (const std::initializer_list< WSR4 > &tensors, Size d=0)
WWR4 dynamic_cat (const std::vector< WWR4 > &tensors, Size d=0)
WWR4 dynamic_cat (const std::initializer_list< WWR4 > &tensors, Size d=0)
WWR4 intmd_cat (const std::vector< WWR4 > &tensors, Size d=0)
WWR4 intmd_cat (const std::initializer_list< WWR4 > &tensors, Size d=0)
Quaternion dynamic_cat (const std::vector< Quaternion > &tensors, Size d=0)
Quaternion dynamic_cat (const std::initializer_list< Quaternion > &tensors, Size d=0)
Quaternion intmd_cat (const std::vector< Quaternion > &tensors, Size d=0)
Quaternion intmd_cat (const std::initializer_list< Quaternion > &tensors, Size d=0)
MillerIndex dynamic_cat (const std::vector< MillerIndex > &tensors, Size d=0)
MillerIndex dynamic_cat (const std::initializer_list< MillerIndex > &tensors, Size d=0)
MillerIndex intmd_cat (const std::vector< MillerIndex > &tensors, Size d=0)
MillerIndex intmd_cat (const std::initializer_list< MillerIndex > &tensors, Size d=0)
Tensor dynamic_cat (const std::vector< Tensor > &tensors, Size d=0)
Tensor dynamic_cat (const std::initializer_list< Tensor > &tensors, Size d=0)
Tensor intmd_cat (const std::vector< Tensor > &tensors, Size d=0)
Tensor intmd_cat (const std::initializer_list< Tensor > &tensors, Size d=0)
Scalar dynamic_cat (const std::vector< Scalar > &tensors, Size d=0)
Scalar dynamic_cat (const std::initializer_list< Scalar > &tensors, Size d=0)
Scalar intmd_cat (const std::vector< Scalar > &tensors, Size d=0)
Scalar intmd_cat (const std::initializer_list< Scalar > &tensors, Size d=0)
Tensor base_cat (const std::vector< Tensor > &tensors, Size d=0)
Vec cbrt (const Vec &a)
Rot cbrt (const Rot &a)
WR2 cbrt (const WR2 &a)
R2 cbrt (const R2 &a)
SR2 cbrt (const SR2 &a)
R3 cbrt (const R3 &a)
SFR3 cbrt (const SFR3 &a)
R4 cbrt (const R4 &a)
SFFR4 cbrt (const SFFR4 &a)
WFFR4 cbrt (const WFFR4 &a)
SSR4 cbrt (const SSR4 &a)
SWR4 cbrt (const SWR4 &a)
WSR4 cbrt (const WSR4 &a)
WWR4 cbrt (const WWR4 &a)
Quaternion cbrt (const Quaternion &a)
MillerIndex cbrt (const MillerIndex &a)
Tensor cbrt (const Tensor &a)
Scalar cbrt (const Scalar &a)
Derivative< 1 > chain_rule (const Derivative< 1 > &dy_du, const Derivative< 1 > &du_dx)
 Apply chain rule on two first-order derivatives.
Derivative< 2 > chain_rule (const Derivative< 2 > &d2y_du1u2, const Derivative< 1 > *du_dx1, const Derivative< 1 > *du_dx2)
Derivative< 2 > chain_rule (const Derivative< 1 > &dy_du, const Derivative< 2 > &d2u_dx1x2)
Vec clamp (const Vec &a, const Vec &lb, const Vec &ub)
Vec clamp (const Vec &a, const CScalar &lb, const CScalar &ub)
Rot clamp (const Rot &a, const Rot &lb, const Rot &ub)
Rot clamp (const Rot &a, const CScalar &lb, const CScalar &ub)
WR2 clamp (const WR2 &a, const WR2 &lb, const WR2 &ub)
WR2 clamp (const WR2 &a, const CScalar &lb, const CScalar &ub)
R2 clamp (const R2 &a, const R2 &lb, const R2 &ub)
R2 clamp (const R2 &a, const CScalar &lb, const CScalar &ub)
SR2 clamp (const SR2 &a, const SR2 &lb, const SR2 &ub)
SR2 clamp (const SR2 &a, const CScalar &lb, const CScalar &ub)
R3 clamp (const R3 &a, const R3 &lb, const R3 &ub)
R3 clamp (const R3 &a, const CScalar &lb, const CScalar &ub)
SFR3 clamp (const SFR3 &a, const SFR3 &lb, const SFR3 &ub)
SFR3 clamp (const SFR3 &a, const CScalar &lb, const CScalar &ub)
R4 clamp (const R4 &a, const R4 &lb, const R4 &ub)
R4 clamp (const R4 &a, const CScalar &lb, const CScalar &ub)
SFFR4 clamp (const SFFR4 &a, const SFFR4 &lb, const SFFR4 &ub)
SFFR4 clamp (const SFFR4 &a, const CScalar &lb, const CScalar &ub)
WFFR4 clamp (const WFFR4 &a, const WFFR4 &lb, const WFFR4 &ub)
WFFR4 clamp (const WFFR4 &a, const CScalar &lb, const CScalar &ub)
SSR4 clamp (const SSR4 &a, const SSR4 &lb, const SSR4 &ub)
SSR4 clamp (const SSR4 &a, const CScalar &lb, const CScalar &ub)
SWR4 clamp (const SWR4 &a, const SWR4 &lb, const SWR4 &ub)
SWR4 clamp (const SWR4 &a, const CScalar &lb, const CScalar &ub)
WSR4 clamp (const WSR4 &a, const WSR4 &lb, const WSR4 &ub)
WSR4 clamp (const WSR4 &a, const CScalar &lb, const CScalar &ub)
WWR4 clamp (const WWR4 &a, const WWR4 &lb, const WWR4 &ub)
WWR4 clamp (const WWR4 &a, const CScalar &lb, const CScalar &ub)
Quaternion clamp (const Quaternion &a, const Quaternion &lb, const Quaternion &ub)
Quaternion clamp (const Quaternion &a, const CScalar &lb, const CScalar &ub)
MillerIndex clamp (const MillerIndex &a, const MillerIndex &lb, const MillerIndex &ub)
MillerIndex clamp (const MillerIndex &a, const CScalar &lb, const CScalar &ub)
Tensor clamp (const Tensor &a, const Tensor &lb, const Tensor &ub)
Tensor clamp (const Tensor &a, const CScalar &lb, const CScalar &ub)
Scalar clamp (const Scalar &a, const Scalar &lb, const Scalar &ub)
Scalar clamp (const Scalar &a, const CScalar &lb, const CScalar &ub)
Vec clip (const Vec &a, const Vec &lb, const Vec &ub)
Vec clip (const Vec &a, const CScalar &lb, const CScalar &ub)
Rot clip (const Rot &a, const Rot &lb, const Rot &ub)
Rot clip (const Rot &a, const CScalar &lb, const CScalar &ub)
WR2 clip (const WR2 &a, const WR2 &lb, const WR2 &ub)
WR2 clip (const WR2 &a, const CScalar &lb, const CScalar &ub)
R2 clip (const R2 &a, const R2 &lb, const R2 &ub)
R2 clip (const R2 &a, const CScalar &lb, const CScalar &ub)
SR2 clip (const SR2 &a, const SR2 &lb, const SR2 &ub)
SR2 clip (const SR2 &a, const CScalar &lb, const CScalar &ub)
R3 clip (const R3 &a, const R3 &lb, const R3 &ub)
R3 clip (const R3 &a, const CScalar &lb, const CScalar &ub)
SFR3 clip (const SFR3 &a, const SFR3 &lb, const SFR3 &ub)
SFR3 clip (const SFR3 &a, const CScalar &lb, const CScalar &ub)
R4 clip (const R4 &a, const R4 &lb, const R4 &ub)
R4 clip (const R4 &a, const CScalar &lb, const CScalar &ub)
SFFR4 clip (const SFFR4 &a, const SFFR4 &lb, const SFFR4 &ub)
SFFR4 clip (const SFFR4 &a, const CScalar &lb, const CScalar &ub)
WFFR4 clip (const WFFR4 &a, const WFFR4 &lb, const WFFR4 &ub)
WFFR4 clip (const WFFR4 &a, const CScalar &lb, const CScalar &ub)
SSR4 clip (const SSR4 &a, const SSR4 &lb, const SSR4 &ub)
SSR4 clip (const SSR4 &a, const CScalar &lb, const CScalar &ub)
SWR4 clip (const SWR4 &a, const SWR4 &lb, const SWR4 &ub)
SWR4 clip (const SWR4 &a, const CScalar &lb, const CScalar &ub)
WSR4 clip (const WSR4 &a, const WSR4 &lb, const WSR4 &ub)
WSR4 clip (const WSR4 &a, const CScalar &lb, const CScalar &ub)
WWR4 clip (const WWR4 &a, const WWR4 &lb, const WWR4 &ub)
WWR4 clip (const WWR4 &a, const CScalar &lb, const CScalar &ub)
Quaternion clip (const Quaternion &a, const Quaternion &lb, const Quaternion &ub)
Quaternion clip (const Quaternion &a, const CScalar &lb, const CScalar &ub)
MillerIndex clip (const MillerIndex &a, const MillerIndex &lb, const MillerIndex &ub)
MillerIndex clip (const MillerIndex &a, const CScalar &lb, const CScalar &ub)
Tensor clip (const Tensor &a, const Tensor &lb, const Tensor &ub)
Tensor clip (const Tensor &a, const CScalar &lb, const CScalar &ub)
Scalar clip (const Scalar &a, const Scalar &lb, const Scalar &ub)
Scalar clip (const Scalar &a, const CScalar &lb, const CScalar &ub)
Vec cos (const Vec &a)
Rot cos (const Rot &a)
WR2 cos (const WR2 &a)
R2 cos (const R2 &a)
SR2 cos (const SR2 &a)
R3 cos (const R3 &a)
SFR3 cos (const SFR3 &a)
R4 cos (const R4 &a)
SFFR4 cos (const SFFR4 &a)
WFFR4 cos (const WFFR4 &a)
SSR4 cos (const SSR4 &a)
SWR4 cos (const SWR4 &a)
WSR4 cos (const WSR4 &a)
WWR4 cos (const WWR4 &a)
Quaternion cos (const Quaternion &a)
MillerIndex cos (const MillerIndex &a)
Tensor cos (const Tensor &a)
Scalar cos (const Scalar &a)
Vec cosh (const Vec &a)
Rot cosh (const Rot &a)
WR2 cosh (const WR2 &a)
R2 cosh (const R2 &a)
SR2 cosh (const SR2 &a)
R3 cosh (const R3 &a)
SFR3 cosh (const SFR3 &a)
R4 cosh (const R4 &a)
SFFR4 cosh (const SFFR4 &a)
WFFR4 cosh (const WFFR4 &a)
SSR4 cosh (const SSR4 &a)
SWR4 cosh (const SWR4 &a)
WSR4 cosh (const WSR4 &a)
WWR4 cosh (const WWR4 &a)
Quaternion cosh (const Quaternion &a)
MillerIndex cosh (const MillerIndex &a)
Tensor cosh (const Tensor &a)
Scalar cosh (const Scalar &a)
Vec cross (const Vec &u, const Vec &v)
Vec deg2rad (const Vec &a)
Rot deg2rad (const Rot &a)
WR2 deg2rad (const WR2 &a)
R2 deg2rad (const R2 &a)
SR2 deg2rad (const SR2 &a)
R3 deg2rad (const R3 &a)
SFR3 deg2rad (const SFR3 &a)
R4 deg2rad (const R4 &a)
SFFR4 deg2rad (const SFFR4 &a)
WFFR4 deg2rad (const WFFR4 &a)
SSR4 deg2rad (const SSR4 &a)
SWR4 deg2rad (const SWR4 &a)
WSR4 deg2rad (const WSR4 &a)
WWR4 deg2rad (const WWR4 &a)
Quaternion deg2rad (const Quaternion &a)
MillerIndex deg2rad (const MillerIndex &a)
Tensor deg2rad (const Tensor &a)
Scalar deg2rad (const Scalar &a)
Vec dynamic_diagonalize (const Vec &a, Size d=-1)
Vec intmd_diagonalize (const Vec &a, Size d=-1)
Rot dynamic_diagonalize (const Rot &a, Size d=-1)
Rot intmd_diagonalize (const Rot &a, Size d=-1)
WR2 dynamic_diagonalize (const WR2 &a, Size d=-1)
WR2 intmd_diagonalize (const WR2 &a, Size d=-1)
R2 dynamic_diagonalize (const R2 &a, Size d=-1)
R2 intmd_diagonalize (const R2 &a, Size d=-1)
SR2 dynamic_diagonalize (const SR2 &a, Size d=-1)
SR2 intmd_diagonalize (const SR2 &a, Size d=-1)
R3 dynamic_diagonalize (const R3 &a, Size d=-1)
R3 intmd_diagonalize (const R3 &a, Size d=-1)
SFR3 dynamic_diagonalize (const SFR3 &a, Size d=-1)
SFR3 intmd_diagonalize (const SFR3 &a, Size d=-1)
R4 dynamic_diagonalize (const R4 &a, Size d=-1)
R4 intmd_diagonalize (const R4 &a, Size d=-1)
SFFR4 dynamic_diagonalize (const SFFR4 &a, Size d=-1)
SFFR4 intmd_diagonalize (const SFFR4 &a, Size d=-1)
WFFR4 dynamic_diagonalize (const WFFR4 &a, Size d=-1)
WFFR4 intmd_diagonalize (const WFFR4 &a, Size d=-1)
SSR4 dynamic_diagonalize (const SSR4 &a, Size d=-1)
SSR4 intmd_diagonalize (const SSR4 &a, Size d=-1)
SWR4 dynamic_diagonalize (const SWR4 &a, Size d=-1)
SWR4 intmd_diagonalize (const SWR4 &a, Size d=-1)
WSR4 dynamic_diagonalize (const WSR4 &a, Size d=-1)
WSR4 intmd_diagonalize (const WSR4 &a, Size d=-1)
WWR4 dynamic_diagonalize (const WWR4 &a, Size d=-1)
WWR4 intmd_diagonalize (const WWR4 &a, Size d=-1)
Quaternion dynamic_diagonalize (const Quaternion &a, Size d=-1)
Quaternion intmd_diagonalize (const Quaternion &a, Size d=-1)
MillerIndex dynamic_diagonalize (const MillerIndex &a, Size d=-1)
MillerIndex intmd_diagonalize (const MillerIndex &a, Size d=-1)
Tensor dynamic_diagonalize (const Tensor &a, Size d=-1)
Tensor intmd_diagonalize (const Tensor &a, Size d=-1)
Scalar dynamic_diagonalize (const Scalar &a, Size d=-1)
Scalar intmd_diagonalize (const Scalar &a, Size d=-1)
Tensor base_diagonalize (const Tensor &a, Size d=-1)
Vec dynamic_diff (const Vec &a, Size n=1, Size dim=-1)
Vec intmd_diff (const Vec &a, Size n=1, Size dim=-1)
Rot dynamic_diff (const Rot &a, Size n=1, Size dim=-1)
Rot intmd_diff (const Rot &a, Size n=1, Size dim=-1)
WR2 dynamic_diff (const WR2 &a, Size n=1, Size dim=-1)
WR2 intmd_diff (const WR2 &a, Size n=1, Size dim=-1)
R2 dynamic_diff (const R2 &a, Size n=1, Size dim=-1)
R2 intmd_diff (const R2 &a, Size n=1, Size dim=-1)
SR2 dynamic_diff (const SR2 &a, Size n=1, Size dim=-1)
SR2 intmd_diff (const SR2 &a, Size n=1, Size dim=-1)
R3 dynamic_diff (const R3 &a, Size n=1, Size dim=-1)
R3 intmd_diff (const R3 &a, Size n=1, Size dim=-1)
SFR3 dynamic_diff (const SFR3 &a, Size n=1, Size dim=-1)
SFR3 intmd_diff (const SFR3 &a, Size n=1, Size dim=-1)
R4 dynamic_diff (const R4 &a, Size n=1, Size dim=-1)
R4 intmd_diff (const R4 &a, Size n=1, Size dim=-1)
SFFR4 dynamic_diff (const SFFR4 &a, Size n=1, Size dim=-1)
SFFR4 intmd_diff (const SFFR4 &a, Size n=1, Size dim=-1)
WFFR4 dynamic_diff (const WFFR4 &a, Size n=1, Size dim=-1)
WFFR4 intmd_diff (const WFFR4 &a, Size n=1, Size dim=-1)
SSR4 dynamic_diff (const SSR4 &a, Size n=1, Size dim=-1)
SSR4 intmd_diff (const SSR4 &a, Size n=1, Size dim=-1)
SWR4 dynamic_diff (const SWR4 &a, Size n=1, Size dim=-1)
SWR4 intmd_diff (const SWR4 &a, Size n=1, Size dim=-1)
WSR4 dynamic_diff (const WSR4 &a, Size n=1, Size dim=-1)
WSR4 intmd_diff (const WSR4 &a, Size n=1, Size dim=-1)
WWR4 dynamic_diff (const WWR4 &a, Size n=1, Size dim=-1)
WWR4 intmd_diff (const WWR4 &a, Size n=1, Size dim=-1)
Quaternion dynamic_diff (const Quaternion &a, Size n=1, Size dim=-1)
Quaternion intmd_diff (const Quaternion &a, Size n=1, Size dim=-1)
MillerIndex dynamic_diff (const MillerIndex &a, Size n=1, Size dim=-1)
MillerIndex intmd_diff (const MillerIndex &a, Size n=1, Size dim=-1)
Tensor dynamic_diff (const Tensor &a, Size n=1, Size dim=-1)
Tensor intmd_diff (const Tensor &a, Size n=1, Size dim=-1)
Scalar dynamic_diff (const Scalar &a, Size n=1, Size dim=-1)
Scalar intmd_diff (const Scalar &a, Size n=1, Size dim=-1)
neml2::Tensor base_diff (const Tensor &a, Size n=1, Size dim=-1)
Tensor einsum (c10::string_view equation, TensorList tensors)
 Einstein summation along base dimensions.
Vec exp (const Vec &a)
Rot exp (const Rot &a)
WR2 exp (const WR2 &a)
R2 exp (const R2 &a)
SR2 exp (const SR2 &a)
R3 exp (const R3 &a)
SFR3 exp (const SFR3 &a)
R4 exp (const R4 &a)
SFFR4 exp (const SFFR4 &a)
WFFR4 exp (const WFFR4 &a)
SSR4 exp (const SSR4 &a)
SWR4 exp (const SWR4 &a)
WSR4 exp (const WSR4 &a)
WWR4 exp (const WWR4 &a)
Quaternion exp (const Quaternion &a)
MillerIndex exp (const MillerIndex &a)
Tensor exp (const Tensor &a)
Scalar exp (const Scalar &a)
Vec fmod (const Vec &a, const Vec &b)
Vec fmod (const Vec &a, const CScalar &b)
Rot fmod (const Rot &a, const Rot &b)
Rot fmod (const Rot &a, const CScalar &b)
WR2 fmod (const WR2 &a, const WR2 &b)
WR2 fmod (const WR2 &a, const CScalar &b)
R2 fmod (const R2 &a, const R2 &b)
R2 fmod (const R2 &a, const CScalar &b)
SR2 fmod (const SR2 &a, const SR2 &b)
SR2 fmod (const SR2 &a, const CScalar &b)
R3 fmod (const R3 &a, const R3 &b)
R3 fmod (const R3 &a, const CScalar &b)
SFR3 fmod (const SFR3 &a, const SFR3 &b)
SFR3 fmod (const SFR3 &a, const CScalar &b)
R4 fmod (const R4 &a, const R4 &b)
R4 fmod (const R4 &a, const CScalar &b)
SFFR4 fmod (const SFFR4 &a, const SFFR4 &b)
SFFR4 fmod (const SFFR4 &a, const CScalar &b)
WFFR4 fmod (const WFFR4 &a, const WFFR4 &b)
WFFR4 fmod (const WFFR4 &a, const CScalar &b)
SSR4 fmod (const SSR4 &a, const SSR4 &b)
SSR4 fmod (const SSR4 &a, const CScalar &b)
SWR4 fmod (const SWR4 &a, const SWR4 &b)
SWR4 fmod (const SWR4 &a, const CScalar &b)
WSR4 fmod (const WSR4 &a, const WSR4 &b)
WSR4 fmod (const WSR4 &a, const CScalar &b)
WWR4 fmod (const WWR4 &a, const WWR4 &b)
WWR4 fmod (const WWR4 &a, const CScalar &b)
Quaternion fmod (const Quaternion &a, const Quaternion &b)
Quaternion fmod (const Quaternion &a, const CScalar &b)
MillerIndex fmod (const MillerIndex &a, const MillerIndex &b)
MillerIndex fmod (const MillerIndex &a, const CScalar &b)
Tensor fmod (const Tensor &a, const Tensor &b)
Tensor fmod (const Tensor &a, const CScalar &b)
Scalar fmod (const Scalar &a, const Scalar &b)
Scalar fmod (const Scalar &a, const CScalar &b)
Vec gcd (const Vec &a, const Vec &b)
Rot gcd (const Rot &a, const Rot &b)
WR2 gcd (const WR2 &a, const WR2 &b)
R2 gcd (const R2 &a, const R2 &b)
SR2 gcd (const SR2 &a, const SR2 &b)
R3 gcd (const R3 &a, const R3 &b)
SFR3 gcd (const SFR3 &a, const SFR3 &b)
R4 gcd (const R4 &a, const R4 &b)
SFFR4 gcd (const SFFR4 &a, const SFFR4 &b)
WFFR4 gcd (const WFFR4 &a, const WFFR4 &b)
SSR4 gcd (const SSR4 &a, const SSR4 &b)
SWR4 gcd (const SWR4 &a, const SWR4 &b)
WSR4 gcd (const WSR4 &a, const WSR4 &b)
WWR4 gcd (const WWR4 &a, const WWR4 &b)
Quaternion gcd (const Quaternion &a, const Quaternion &b)
MillerIndex gcd (const MillerIndex &a, const MillerIndex &b)
Tensor gcd (const Tensor &a, const Tensor &b)
Scalar gcd (const Scalar &a, const Scalar &b)
Vec heaviside (const Vec &a)
Rot heaviside (const Rot &a)
WR2 heaviside (const WR2 &a)
R2 heaviside (const R2 &a)
SR2 heaviside (const SR2 &a)
R3 heaviside (const R3 &a)
SFR3 heaviside (const SFR3 &a)
R4 heaviside (const R4 &a)
SFFR4 heaviside (const SFFR4 &a)
WFFR4 heaviside (const WFFR4 &a)
SSR4 heaviside (const SSR4 &a)
SWR4 heaviside (const SWR4 &a)
WSR4 heaviside (const WSR4 &a)
WWR4 heaviside (const WWR4 &a)
Quaternion heaviside (const Quaternion &a)
MillerIndex heaviside (const MillerIndex &a)
Tensor heaviside (const Tensor &a)
Scalar heaviside (const Scalar &a)
template<typename T>
DTensor< T, T, typename imap_t< T >::type > imap (const TensorOptions &options=default_tensor_options())
 Identity map.
template<typename T>
imap_t< T >::type imap_v (const TensorOptions &options=default_tensor_options())
 Get the identity map interpreted as the concrete primitive tensor type.
template<>
DTensor< Scalar, Scalar, typename imap_t< Scalar >::type > imap (const TensorOptions &options)
template<>
DTensor< Vec, Vec, typename imap_t< Vec >::type > imap (const TensorOptions &options)
template<>
DTensor< R2, R2, typename imap_t< R2 >::type > imap (const TensorOptions &options)
template<>
DTensor< SR2, SR2, typename imap_t< SR2 >::type > imap (const TensorOptions &options)
template<>
DTensor< SSR4, SSR4, typename imap_t< SSR4 >::type > imap (const TensorOptions &options)
Scalar inner (const Tensor &a, const Tensor &b)
 Inner product.
Tensor inv (const Tensor &)
 Inverse of a second order or fourth order tensor.
Rot inv (const Rot &)
 Inverse of a rotation (MRP).
std::vector< Tensorjacrev (const Tensor &y, const std::vector< Tensor > &xs, bool retain_graph=false, bool create_graph=false, bool allow_unused=false)
 Use automatic differentiation (AD) to calculate the derivatives of a Tensor w.r.t. another Tensor.
Tensor jacrev (const Tensor &y, const Tensor &x, bool retain_graph=false, bool create_graph=false, bool allow_unused=false)
 Similar to the other jacrev, but for a single input.
Vec log (const Vec &a)
Rot log (const Rot &a)
WR2 log (const WR2 &a)
R2 log (const R2 &a)
SR2 log (const SR2 &a)
R3 log (const R3 &a)
SFR3 log (const SFR3 &a)
R4 log (const R4 &a)
SFFR4 log (const SFFR4 &a)
WFFR4 log (const WFFR4 &a)
SSR4 log (const SSR4 &a)
SWR4 log (const SWR4 &a)
WSR4 log (const WSR4 &a)
WWR4 log (const WWR4 &a)
Quaternion log (const Quaternion &a)
MillerIndex log (const MillerIndex &a)
Tensor log (const Tensor &a)
Scalar log (const Scalar &a)
Vec log10 (const Vec &a)
Rot log10 (const Rot &a)
WR2 log10 (const WR2 &a)
R2 log10 (const R2 &a)
SR2 log10 (const SR2 &a)
R3 log10 (const R3 &a)
SFR3 log10 (const SFR3 &a)
R4 log10 (const R4 &a)
SFFR4 log10 (const SFFR4 &a)
WFFR4 log10 (const WFFR4 &a)
SSR4 log10 (const SSR4 &a)
SWR4 log10 (const SWR4 &a)
WSR4 log10 (const WSR4 &a)
WWR4 log10 (const WWR4 &a)
Quaternion log10 (const Quaternion &a)
MillerIndex log10 (const MillerIndex &a)
Tensor log10 (const Tensor &a)
Scalar log10 (const Scalar &a)
Vec operator> (const Vec &a, const Vec &b)
Vec operator< (const Vec &a, const Vec &b)
Vec operator>= (const Vec &a, const Vec &b)
Vec operator<= (const Vec &a, const Vec &b)
Vec operator&& (const Vec &a, const Vec &b)
Vec operator|| (const Vec &a, const Vec &b)
Vec operator== (const Vec &a, const Vec &b)
Vec operator!= (const Vec &a, const Vec &b)
Vec gt (const Vec &a, const Vec &b)
Vec lt (const Vec &a, const Vec &b)
Vec ge (const Vec &a, const Vec &b)
Vec le (const Vec &a, const Vec &b)
Vec logical_and (const Vec &a, const Vec &b)
Vec logical_or (const Vec &a, const Vec &b)
Vec logical_xor (const Vec &a, const Vec &b)
Vec eq (const Vec &a, const Vec &b)
Vec ne (const Vec &a, const Vec &b)
Vec operator! (const Vec &a)
Vec logical_not (const Vec &a)
Rot operator> (const Rot &a, const Rot &b)
Rot operator< (const Rot &a, const Rot &b)
Rot operator>= (const Rot &a, const Rot &b)
Rot operator<= (const Rot &a, const Rot &b)
Rot operator&& (const Rot &a, const Rot &b)
Rot operator|| (const Rot &a, const Rot &b)
Rot operator== (const Rot &a, const Rot &b)
Rot operator!= (const Rot &a, const Rot &b)
Rot gt (const Rot &a, const Rot &b)
Rot lt (const Rot &a, const Rot &b)
Rot ge (const Rot &a, const Rot &b)
Rot le (const Rot &a, const Rot &b)
Rot logical_and (const Rot &a, const Rot &b)
Rot logical_or (const Rot &a, const Rot &b)
Rot logical_xor (const Rot &a, const Rot &b)
Rot eq (const Rot &a, const Rot &b)
Rot ne (const Rot &a, const Rot &b)
Rot operator! (const Rot &a)
Rot logical_not (const Rot &a)
WR2 operator> (const WR2 &a, const WR2 &b)
WR2 operator< (const WR2 &a, const WR2 &b)
WR2 operator>= (const WR2 &a, const WR2 &b)
WR2 operator<= (const WR2 &a, const WR2 &b)
WR2 operator&& (const WR2 &a, const WR2 &b)
WR2 operator|| (const WR2 &a, const WR2 &b)
WR2 operator== (const WR2 &a, const WR2 &b)
WR2 operator!= (const WR2 &a, const WR2 &b)
WR2 gt (const WR2 &a, const WR2 &b)
WR2 lt (const WR2 &a, const WR2 &b)
WR2 ge (const WR2 &a, const WR2 &b)
WR2 le (const WR2 &a, const WR2 &b)
WR2 logical_and (const WR2 &a, const WR2 &b)
WR2 logical_or (const WR2 &a, const WR2 &b)
WR2 logical_xor (const WR2 &a, const WR2 &b)
WR2 eq (const WR2 &a, const WR2 &b)
WR2 ne (const WR2 &a, const WR2 &b)
WR2 operator! (const WR2 &a)
WR2 logical_not (const WR2 &a)
R2 operator> (const R2 &a, const R2 &b)
R2 operator< (const R2 &a, const R2 &b)
R2 operator>= (const R2 &a, const R2 &b)
R2 operator<= (const R2 &a, const R2 &b)
R2 operator&& (const R2 &a, const R2 &b)
R2 operator|| (const R2 &a, const R2 &b)
R2 operator== (const R2 &a, const R2 &b)
R2 operator!= (const R2 &a, const R2 &b)
R2 gt (const R2 &a, const R2 &b)
R2 lt (const R2 &a, const R2 &b)
R2 ge (const R2 &a, const R2 &b)
R2 le (const R2 &a, const R2 &b)
R2 logical_and (const R2 &a, const R2 &b)
R2 logical_or (const R2 &a, const R2 &b)
R2 logical_xor (const R2 &a, const R2 &b)
R2 eq (const R2 &a, const R2 &b)
R2 ne (const R2 &a, const R2 &b)
R2 operator! (const R2 &a)
R2 logical_not (const R2 &a)
SR2 operator> (const SR2 &a, const SR2 &b)
SR2 operator< (const SR2 &a, const SR2 &b)
SR2 operator>= (const SR2 &a, const SR2 &b)
SR2 operator<= (const SR2 &a, const SR2 &b)
SR2 operator&& (const SR2 &a, const SR2 &b)
SR2 operator|| (const SR2 &a, const SR2 &b)
SR2 operator== (const SR2 &a, const SR2 &b)
SR2 operator!= (const SR2 &a, const SR2 &b)
SR2 gt (const SR2 &a, const SR2 &b)
SR2 lt (const SR2 &a, const SR2 &b)
SR2 ge (const SR2 &a, const SR2 &b)
SR2 le (const SR2 &a, const SR2 &b)
SR2 logical_and (const SR2 &a, const SR2 &b)
SR2 logical_or (const SR2 &a, const SR2 &b)
SR2 logical_xor (const SR2 &a, const SR2 &b)
SR2 eq (const SR2 &a, const SR2 &b)
SR2 ne (const SR2 &a, const SR2 &b)
SR2 operator! (const SR2 &a)
SR2 logical_not (const SR2 &a)
R3 operator> (const R3 &a, const R3 &b)
R3 operator< (const R3 &a, const R3 &b)
R3 operator>= (const R3 &a, const R3 &b)
R3 operator<= (const R3 &a, const R3 &b)
R3 operator&& (const R3 &a, const R3 &b)
R3 operator|| (const R3 &a, const R3 &b)
R3 operator== (const R3 &a, const R3 &b)
R3 operator!= (const R3 &a, const R3 &b)
R3 gt (const R3 &a, const R3 &b)
R3 lt (const R3 &a, const R3 &b)
R3 ge (const R3 &a, const R3 &b)
R3 le (const R3 &a, const R3 &b)
R3 logical_and (const R3 &a, const R3 &b)
R3 logical_or (const R3 &a, const R3 &b)
R3 logical_xor (const R3 &a, const R3 &b)
R3 eq (const R3 &a, const R3 &b)
R3 ne (const R3 &a, const R3 &b)
R3 operator! (const R3 &a)
R3 logical_not (const R3 &a)
SFR3 operator> (const SFR3 &a, const SFR3 &b)
SFR3 operator< (const SFR3 &a, const SFR3 &b)
SFR3 operator>= (const SFR3 &a, const SFR3 &b)
SFR3 operator<= (const SFR3 &a, const SFR3 &b)
SFR3 operator&& (const SFR3 &a, const SFR3 &b)
SFR3 operator|| (const SFR3 &a, const SFR3 &b)
SFR3 operator== (const SFR3 &a, const SFR3 &b)
SFR3 operator!= (const SFR3 &a, const SFR3 &b)
SFR3 gt (const SFR3 &a, const SFR3 &b)
SFR3 lt (const SFR3 &a, const SFR3 &b)
SFR3 ge (const SFR3 &a, const SFR3 &b)
SFR3 le (const SFR3 &a, const SFR3 &b)
SFR3 logical_and (const SFR3 &a, const SFR3 &b)
SFR3 logical_or (const SFR3 &a, const SFR3 &b)
SFR3 logical_xor (const SFR3 &a, const SFR3 &b)
SFR3 eq (const SFR3 &a, const SFR3 &b)
SFR3 ne (const SFR3 &a, const SFR3 &b)
SFR3 operator! (const SFR3 &a)
SFR3 logical_not (const SFR3 &a)
R4 operator> (const R4 &a, const R4 &b)
R4 operator< (const R4 &a, const R4 &b)
R4 operator>= (const R4 &a, const R4 &b)
R4 operator<= (const R4 &a, const R4 &b)
R4 operator&& (const R4 &a, const R4 &b)
R4 operator|| (const R4 &a, const R4 &b)
R4 operator== (const R4 &a, const R4 &b)
R4 operator!= (const R4 &a, const R4 &b)
R4 gt (const R4 &a, const R4 &b)
R4 lt (const R4 &a, const R4 &b)
R4 ge (const R4 &a, const R4 &b)
R4 le (const R4 &a, const R4 &b)
R4 logical_and (const R4 &a, const R4 &b)
R4 logical_or (const R4 &a, const R4 &b)
R4 logical_xor (const R4 &a, const R4 &b)
R4 eq (const R4 &a, const R4 &b)
R4 ne (const R4 &a, const R4 &b)
R4 operator! (const R4 &a)
R4 logical_not (const R4 &a)
SFFR4 operator> (const SFFR4 &a, const SFFR4 &b)
SFFR4 operator< (const SFFR4 &a, const SFFR4 &b)
SFFR4 operator>= (const SFFR4 &a, const SFFR4 &b)
SFFR4 operator<= (const SFFR4 &a, const SFFR4 &b)
SFFR4 operator&& (const SFFR4 &a, const SFFR4 &b)
SFFR4 operator|| (const SFFR4 &a, const SFFR4 &b)
SFFR4 operator== (const SFFR4 &a, const SFFR4 &b)
SFFR4 operator!= (const SFFR4 &a, const SFFR4 &b)
SFFR4 gt (const SFFR4 &a, const SFFR4 &b)
SFFR4 lt (const SFFR4 &a, const SFFR4 &b)
SFFR4 ge (const SFFR4 &a, const SFFR4 &b)
SFFR4 le (const SFFR4 &a, const SFFR4 &b)
SFFR4 logical_and (const SFFR4 &a, const SFFR4 &b)
SFFR4 logical_or (const SFFR4 &a, const SFFR4 &b)
SFFR4 logical_xor (const SFFR4 &a, const SFFR4 &b)
SFFR4 eq (const SFFR4 &a, const SFFR4 &b)
SFFR4 ne (const SFFR4 &a, const SFFR4 &b)
SFFR4 operator! (const SFFR4 &a)
SFFR4 logical_not (const SFFR4 &a)
WFFR4 operator> (const WFFR4 &a, const WFFR4 &b)
WFFR4 operator< (const WFFR4 &a, const WFFR4 &b)
WFFR4 operator>= (const WFFR4 &a, const WFFR4 &b)
WFFR4 operator<= (const WFFR4 &a, const WFFR4 &b)
WFFR4 operator&& (const WFFR4 &a, const WFFR4 &b)
WFFR4 operator|| (const WFFR4 &a, const WFFR4 &b)
WFFR4 operator== (const WFFR4 &a, const WFFR4 &b)
WFFR4 operator!= (const WFFR4 &a, const WFFR4 &b)
WFFR4 gt (const WFFR4 &a, const WFFR4 &b)
WFFR4 lt (const WFFR4 &a, const WFFR4 &b)
WFFR4 ge (const WFFR4 &a, const WFFR4 &b)
WFFR4 le (const WFFR4 &a, const WFFR4 &b)
WFFR4 logical_and (const WFFR4 &a, const WFFR4 &b)
WFFR4 logical_or (const WFFR4 &a, const WFFR4 &b)
WFFR4 logical_xor (const WFFR4 &a, const WFFR4 &b)
WFFR4 eq (const WFFR4 &a, const WFFR4 &b)
WFFR4 ne (const WFFR4 &a, const WFFR4 &b)
WFFR4 operator! (const WFFR4 &a)
WFFR4 logical_not (const WFFR4 &a)
SSR4 operator> (const SSR4 &a, const SSR4 &b)
SSR4 operator< (const SSR4 &a, const SSR4 &b)
SSR4 operator>= (const SSR4 &a, const SSR4 &b)
SSR4 operator<= (const SSR4 &a, const SSR4 &b)
SSR4 operator&& (const SSR4 &a, const SSR4 &b)
SSR4 operator|| (const SSR4 &a, const SSR4 &b)
SSR4 operator== (const SSR4 &a, const SSR4 &b)
SSR4 operator!= (const SSR4 &a, const SSR4 &b)
SSR4 gt (const SSR4 &a, const SSR4 &b)
SSR4 lt (const SSR4 &a, const SSR4 &b)
SSR4 ge (const SSR4 &a, const SSR4 &b)
SSR4 le (const SSR4 &a, const SSR4 &b)
SSR4 logical_and (const SSR4 &a, const SSR4 &b)
SSR4 logical_or (const SSR4 &a, const SSR4 &b)
SSR4 logical_xor (const SSR4 &a, const SSR4 &b)
SSR4 eq (const SSR4 &a, const SSR4 &b)
SSR4 ne (const SSR4 &a, const SSR4 &b)
SSR4 operator! (const SSR4 &a)
SSR4 logical_not (const SSR4 &a)
SWR4 operator> (const SWR4 &a, const SWR4 &b)
SWR4 operator< (const SWR4 &a, const SWR4 &b)
SWR4 operator>= (const SWR4 &a, const SWR4 &b)
SWR4 operator<= (const SWR4 &a, const SWR4 &b)
SWR4 operator&& (const SWR4 &a, const SWR4 &b)
SWR4 operator|| (const SWR4 &a, const SWR4 &b)
SWR4 operator== (const SWR4 &a, const SWR4 &b)
SWR4 operator!= (const SWR4 &a, const SWR4 &b)
SWR4 gt (const SWR4 &a, const SWR4 &b)
SWR4 lt (const SWR4 &a, const SWR4 &b)
SWR4 ge (const SWR4 &a, const SWR4 &b)
SWR4 le (const SWR4 &a, const SWR4 &b)
SWR4 logical_and (const SWR4 &a, const SWR4 &b)
SWR4 logical_or (const SWR4 &a, const SWR4 &b)
SWR4 logical_xor (const SWR4 &a, const SWR4 &b)
SWR4 eq (const SWR4 &a, const SWR4 &b)
SWR4 ne (const SWR4 &a, const SWR4 &b)
SWR4 operator! (const SWR4 &a)
SWR4 logical_not (const SWR4 &a)
WSR4 operator> (const WSR4 &a, const WSR4 &b)
WSR4 operator< (const WSR4 &a, const WSR4 &b)
WSR4 operator>= (const WSR4 &a, const WSR4 &b)
WSR4 operator<= (const WSR4 &a, const WSR4 &b)
WSR4 operator&& (const WSR4 &a, const WSR4 &b)
WSR4 operator|| (const WSR4 &a, const WSR4 &b)
WSR4 operator== (const WSR4 &a, const WSR4 &b)
WSR4 operator!= (const WSR4 &a, const WSR4 &b)
WSR4 gt (const WSR4 &a, const WSR4 &b)
WSR4 lt (const WSR4 &a, const WSR4 &b)
WSR4 ge (const WSR4 &a, const WSR4 &b)
WSR4 le (const WSR4 &a, const WSR4 &b)
WSR4 logical_and (const WSR4 &a, const WSR4 &b)
WSR4 logical_or (const WSR4 &a, const WSR4 &b)
WSR4 logical_xor (const WSR4 &a, const WSR4 &b)
WSR4 eq (const WSR4 &a, const WSR4 &b)
WSR4 ne (const WSR4 &a, const WSR4 &b)
WSR4 operator! (const WSR4 &a)
WSR4 logical_not (const WSR4 &a)
WWR4 operator> (const WWR4 &a, const WWR4 &b)
WWR4 operator< (const WWR4 &a, const WWR4 &b)
WWR4 operator>= (const WWR4 &a, const WWR4 &b)
WWR4 operator<= (const WWR4 &a, const WWR4 &b)
WWR4 operator&& (const WWR4 &a, const WWR4 &b)
WWR4 operator|| (const WWR4 &a, const WWR4 &b)
WWR4 operator== (const WWR4 &a, const WWR4 &b)
WWR4 operator!= (const WWR4 &a, const WWR4 &b)
WWR4 gt (const WWR4 &a, const WWR4 &b)
WWR4 lt (const WWR4 &a, const WWR4 &b)
WWR4 ge (const WWR4 &a, const WWR4 &b)
WWR4 le (const WWR4 &a, const WWR4 &b)
WWR4 logical_and (const WWR4 &a, const WWR4 &b)
WWR4 logical_or (const WWR4 &a, const WWR4 &b)
WWR4 logical_xor (const WWR4 &a, const WWR4 &b)
WWR4 eq (const WWR4 &a, const WWR4 &b)
WWR4 ne (const WWR4 &a, const WWR4 &b)
WWR4 operator! (const WWR4 &a)
WWR4 logical_not (const WWR4 &a)
Quaternion operator> (const Quaternion &a, const Quaternion &b)
Quaternion operator< (const Quaternion &a, const Quaternion &b)
Quaternion operator>= (const Quaternion &a, const Quaternion &b)
Quaternion operator<= (const Quaternion &a, const Quaternion &b)
Quaternion operator&& (const Quaternion &a, const Quaternion &b)
Quaternion operator|| (const Quaternion &a, const Quaternion &b)
Quaternion operator== (const Quaternion &a, const Quaternion &b)
Quaternion operator!= (const Quaternion &a, const Quaternion &b)
Quaternion gt (const Quaternion &a, const Quaternion &b)
Quaternion lt (const Quaternion &a, const Quaternion &b)
Quaternion ge (const Quaternion &a, const Quaternion &b)
Quaternion le (const Quaternion &a, const Quaternion &b)
Quaternion logical_and (const Quaternion &a, const Quaternion &b)
Quaternion logical_or (const Quaternion &a, const Quaternion &b)
Quaternion logical_xor (const Quaternion &a, const Quaternion &b)
Quaternion eq (const Quaternion &a, const Quaternion &b)
Quaternion ne (const Quaternion &a, const Quaternion &b)
Quaternion operator! (const Quaternion &a)
Quaternion logical_not (const Quaternion &a)
MillerIndex operator> (const MillerIndex &a, const MillerIndex &b)
MillerIndex operator< (const MillerIndex &a, const MillerIndex &b)
MillerIndex operator>= (const MillerIndex &a, const MillerIndex &b)
MillerIndex operator<= (const MillerIndex &a, const MillerIndex &b)
MillerIndex operator&& (const MillerIndex &a, const MillerIndex &b)
MillerIndex operator|| (const MillerIndex &a, const MillerIndex &b)
MillerIndex operator== (const MillerIndex &a, const MillerIndex &b)
MillerIndex operator!= (const MillerIndex &a, const MillerIndex &b)
MillerIndex gt (const MillerIndex &a, const MillerIndex &b)
MillerIndex lt (const MillerIndex &a, const MillerIndex &b)
MillerIndex ge (const MillerIndex &a, const MillerIndex &b)
MillerIndex le (const MillerIndex &a, const MillerIndex &b)
MillerIndex logical_and (const MillerIndex &a, const MillerIndex &b)
MillerIndex logical_or (const MillerIndex &a, const MillerIndex &b)
MillerIndex logical_xor (const MillerIndex &a, const MillerIndex &b)
MillerIndex eq (const MillerIndex &a, const MillerIndex &b)
MillerIndex ne (const MillerIndex &a, const MillerIndex &b)
MillerIndex operator! (const MillerIndex &a)
MillerIndex logical_not (const MillerIndex &a)
Vec operator> (const Vec &a, const Scalar &b)
Vec operator> (const Scalar &a, const Vec &b)
Vec operator< (const Vec &a, const Scalar &b)
Vec operator< (const Scalar &a, const Vec &b)
Vec operator>= (const Vec &a, const Scalar &b)
Vec operator>= (const Scalar &a, const Vec &b)
Vec operator<= (const Vec &a, const Scalar &b)
Vec operator<= (const Scalar &a, const Vec &b)
Vec operator&& (const Vec &a, const Scalar &b)
Vec operator&& (const Scalar &a, const Vec &b)
Vec operator|| (const Vec &a, const Scalar &b)
Vec operator|| (const Scalar &a, const Vec &b)
Vec operator== (const Vec &a, const Scalar &b)
Vec operator== (const Scalar &a, const Vec &b)
Vec operator!= (const Vec &a, const Scalar &b)
Vec operator!= (const Scalar &a, const Vec &b)
Vec gt (const Vec &a, const Scalar &b)
Vec gt (const Scalar &a, const Vec &b)
Vec lt (const Vec &a, const Scalar &b)
Vec lt (const Scalar &a, const Vec &b)
Vec ge (const Vec &a, const Scalar &b)
Vec ge (const Scalar &a, const Vec &b)
Vec le (const Vec &a, const Scalar &b)
Vec le (const Scalar &a, const Vec &b)
Vec logical_and (const Vec &a, const Scalar &b)
Vec logical_and (const Scalar &a, const Vec &b)
Vec logical_or (const Vec &a, const Scalar &b)
Vec logical_or (const Scalar &a, const Vec &b)
Vec logical_xor (const Vec &a, const Scalar &b)
Vec logical_xor (const Scalar &a, const Vec &b)
Vec eq (const Vec &a, const Scalar &b)
Vec eq (const Scalar &a, const Vec &b)
Vec ne (const Vec &a, const Scalar &b)
Vec ne (const Scalar &a, const Vec &b)
Rot operator> (const Rot &a, const Scalar &b)
Rot operator> (const Scalar &a, const Rot &b)
Rot operator< (const Rot &a, const Scalar &b)
Rot operator< (const Scalar &a, const Rot &b)
Rot operator>= (const Rot &a, const Scalar &b)
Rot operator>= (const Scalar &a, const Rot &b)
Rot operator<= (const Rot &a, const Scalar &b)
Rot operator<= (const Scalar &a, const Rot &b)
Rot operator&& (const Rot &a, const Scalar &b)
Rot operator&& (const Scalar &a, const Rot &b)
Rot operator|| (const Rot &a, const Scalar &b)
Rot operator|| (const Scalar &a, const Rot &b)
Rot operator== (const Rot &a, const Scalar &b)
Rot operator== (const Scalar &a, const Rot &b)
Rot operator!= (const Rot &a, const Scalar &b)
Rot operator!= (const Scalar &a, const Rot &b)
Rot gt (const Rot &a, const Scalar &b)
Rot gt (const Scalar &a, const Rot &b)
Rot lt (const Rot &a, const Scalar &b)
Rot lt (const Scalar &a, const Rot &b)
Rot ge (const Rot &a, const Scalar &b)
Rot ge (const Scalar &a, const Rot &b)
Rot le (const Rot &a, const Scalar &b)
Rot le (const Scalar &a, const Rot &b)
Rot logical_and (const Rot &a, const Scalar &b)
Rot logical_and (const Scalar &a, const Rot &b)
Rot logical_or (const Rot &a, const Scalar &b)
Rot logical_or (const Scalar &a, const Rot &b)
Rot logical_xor (const Rot &a, const Scalar &b)
Rot logical_xor (const Scalar &a, const Rot &b)
Rot eq (const Rot &a, const Scalar &b)
Rot eq (const Scalar &a, const Rot &b)
Rot ne (const Rot &a, const Scalar &b)
Rot ne (const Scalar &a, const Rot &b)
WR2 operator> (const WR2 &a, const Scalar &b)
WR2 operator> (const Scalar &a, const WR2 &b)
WR2 operator< (const WR2 &a, const Scalar &b)
WR2 operator< (const Scalar &a, const WR2 &b)
WR2 operator>= (const WR2 &a, const Scalar &b)
WR2 operator>= (const Scalar &a, const WR2 &b)
WR2 operator<= (const WR2 &a, const Scalar &b)
WR2 operator<= (const Scalar &a, const WR2 &b)
WR2 operator&& (const WR2 &a, const Scalar &b)
WR2 operator&& (const Scalar &a, const WR2 &b)
WR2 operator|| (const WR2 &a, const Scalar &b)
WR2 operator|| (const Scalar &a, const WR2 &b)
WR2 operator== (const WR2 &a, const Scalar &b)
WR2 operator== (const Scalar &a, const WR2 &b)
WR2 operator!= (const WR2 &a, const Scalar &b)
WR2 operator!= (const Scalar &a, const WR2 &b)
WR2 gt (const WR2 &a, const Scalar &b)
WR2 gt (const Scalar &a, const WR2 &b)
WR2 lt (const WR2 &a, const Scalar &b)
WR2 lt (const Scalar &a, const WR2 &b)
WR2 ge (const WR2 &a, const Scalar &b)
WR2 ge (const Scalar &a, const WR2 &b)
WR2 le (const WR2 &a, const Scalar &b)
WR2 le (const Scalar &a, const WR2 &b)
WR2 logical_and (const WR2 &a, const Scalar &b)
WR2 logical_and (const Scalar &a, const WR2 &b)
WR2 logical_or (const WR2 &a, const Scalar &b)
WR2 logical_or (const Scalar &a, const WR2 &b)
WR2 logical_xor (const WR2 &a, const Scalar &b)
WR2 logical_xor (const Scalar &a, const WR2 &b)
WR2 eq (const WR2 &a, const Scalar &b)
WR2 eq (const Scalar &a, const WR2 &b)
WR2 ne (const WR2 &a, const Scalar &b)
WR2 ne (const Scalar &a, const WR2 &b)
R2 operator> (const R2 &a, const Scalar &b)
R2 operator> (const Scalar &a, const R2 &b)
R2 operator< (const R2 &a, const Scalar &b)
R2 operator< (const Scalar &a, const R2 &b)
R2 operator>= (const R2 &a, const Scalar &b)
R2 operator>= (const Scalar &a, const R2 &b)
R2 operator<= (const R2 &a, const Scalar &b)
R2 operator<= (const Scalar &a, const R2 &b)
R2 operator&& (const R2 &a, const Scalar &b)
R2 operator&& (const Scalar &a, const R2 &b)
R2 operator|| (const R2 &a, const Scalar &b)
R2 operator|| (const Scalar &a, const R2 &b)
R2 operator== (const R2 &a, const Scalar &b)
R2 operator== (const Scalar &a, const R2 &b)
R2 operator!= (const R2 &a, const Scalar &b)
R2 operator!= (const Scalar &a, const R2 &b)
R2 gt (const R2 &a, const Scalar &b)
R2 gt (const Scalar &a, const R2 &b)
R2 lt (const R2 &a, const Scalar &b)
R2 lt (const Scalar &a, const R2 &b)
R2 ge (const R2 &a, const Scalar &b)
R2 ge (const Scalar &a, const R2 &b)
R2 le (const R2 &a, const Scalar &b)
R2 le (const Scalar &a, const R2 &b)
R2 logical_and (const R2 &a, const Scalar &b)
R2 logical_and (const Scalar &a, const R2 &b)
R2 logical_or (const R2 &a, const Scalar &b)
R2 logical_or (const Scalar &a, const R2 &b)
R2 logical_xor (const R2 &a, const Scalar &b)
R2 logical_xor (const Scalar &a, const R2 &b)
R2 eq (const R2 &a, const Scalar &b)
R2 eq (const Scalar &a, const R2 &b)
R2 ne (const R2 &a, const Scalar &b)
R2 ne (const Scalar &a, const R2 &b)
SR2 operator> (const SR2 &a, const Scalar &b)
SR2 operator> (const Scalar &a, const SR2 &b)
SR2 operator< (const SR2 &a, const Scalar &b)
SR2 operator< (const Scalar &a, const SR2 &b)
SR2 operator>= (const SR2 &a, const Scalar &b)
SR2 operator>= (const Scalar &a, const SR2 &b)
SR2 operator<= (const SR2 &a, const Scalar &b)
SR2 operator<= (const Scalar &a, const SR2 &b)
SR2 operator&& (const SR2 &a, const Scalar &b)
SR2 operator&& (const Scalar &a, const SR2 &b)
SR2 operator|| (const SR2 &a, const Scalar &b)
SR2 operator|| (const Scalar &a, const SR2 &b)
SR2 operator== (const SR2 &a, const Scalar &b)
SR2 operator== (const Scalar &a, const SR2 &b)
SR2 operator!= (const SR2 &a, const Scalar &b)
SR2 operator!= (const Scalar &a, const SR2 &b)
SR2 gt (const SR2 &a, const Scalar &b)
SR2 gt (const Scalar &a, const SR2 &b)
SR2 lt (const SR2 &a, const Scalar &b)
SR2 lt (const Scalar &a, const SR2 &b)
SR2 ge (const SR2 &a, const Scalar &b)
SR2 ge (const Scalar &a, const SR2 &b)
SR2 le (const SR2 &a, const Scalar &b)
SR2 le (const Scalar &a, const SR2 &b)
SR2 logical_and (const SR2 &a, const Scalar &b)
SR2 logical_and (const Scalar &a, const SR2 &b)
SR2 logical_or (const SR2 &a, const Scalar &b)
SR2 logical_or (const Scalar &a, const SR2 &b)
SR2 logical_xor (const SR2 &a, const Scalar &b)
SR2 logical_xor (const Scalar &a, const SR2 &b)
SR2 eq (const SR2 &a, const Scalar &b)
SR2 eq (const Scalar &a, const SR2 &b)
SR2 ne (const SR2 &a, const Scalar &b)
SR2 ne (const Scalar &a, const SR2 &b)
R3 operator> (const R3 &a, const Scalar &b)
R3 operator> (const Scalar &a, const R3 &b)
R3 operator< (const R3 &a, const Scalar &b)
R3 operator< (const Scalar &a, const R3 &b)
R3 operator>= (const R3 &a, const Scalar &b)
R3 operator>= (const Scalar &a, const R3 &b)
R3 operator<= (const R3 &a, const Scalar &b)
R3 operator<= (const Scalar &a, const R3 &b)
R3 operator&& (const R3 &a, const Scalar &b)
R3 operator&& (const Scalar &a, const R3 &b)
R3 operator|| (const R3 &a, const Scalar &b)
R3 operator|| (const Scalar &a, const R3 &b)
R3 operator== (const R3 &a, const Scalar &b)
R3 operator== (const Scalar &a, const R3 &b)
R3 operator!= (const R3 &a, const Scalar &b)
R3 operator!= (const Scalar &a, const R3 &b)
R3 gt (const R3 &a, const Scalar &b)
R3 gt (const Scalar &a, const R3 &b)
R3 lt (const R3 &a, const Scalar &b)
R3 lt (const Scalar &a, const R3 &b)
R3 ge (const R3 &a, const Scalar &b)
R3 ge (const Scalar &a, const R3 &b)
R3 le (const R3 &a, const Scalar &b)
R3 le (const Scalar &a, const R3 &b)
R3 logical_and (const R3 &a, const Scalar &b)
R3 logical_and (const Scalar &a, const R3 &b)
R3 logical_or (const R3 &a, const Scalar &b)
R3 logical_or (const Scalar &a, const R3 &b)
R3 logical_xor (const R3 &a, const Scalar &b)
R3 logical_xor (const Scalar &a, const R3 &b)
R3 eq (const R3 &a, const Scalar &b)
R3 eq (const Scalar &a, const R3 &b)
R3 ne (const R3 &a, const Scalar &b)
R3 ne (const Scalar &a, const R3 &b)
SFR3 operator> (const SFR3 &a, const Scalar &b)
SFR3 operator> (const Scalar &a, const SFR3 &b)
SFR3 operator< (const SFR3 &a, const Scalar &b)
SFR3 operator< (const Scalar &a, const SFR3 &b)
SFR3 operator>= (const SFR3 &a, const Scalar &b)
SFR3 operator>= (const Scalar &a, const SFR3 &b)
SFR3 operator<= (const SFR3 &a, const Scalar &b)
SFR3 operator<= (const Scalar &a, const SFR3 &b)
SFR3 operator&& (const SFR3 &a, const Scalar &b)
SFR3 operator&& (const Scalar &a, const SFR3 &b)
SFR3 operator|| (const SFR3 &a, const Scalar &b)
SFR3 operator|| (const Scalar &a, const SFR3 &b)
SFR3 operator== (const SFR3 &a, const Scalar &b)
SFR3 operator== (const Scalar &a, const SFR3 &b)
SFR3 operator!= (const SFR3 &a, const Scalar &b)
SFR3 operator!= (const Scalar &a, const SFR3 &b)
SFR3 gt (const SFR3 &a, const Scalar &b)
SFR3 gt (const Scalar &a, const SFR3 &b)
SFR3 lt (const SFR3 &a, const Scalar &b)
SFR3 lt (const Scalar &a, const SFR3 &b)
SFR3 ge (const SFR3 &a, const Scalar &b)
SFR3 ge (const Scalar &a, const SFR3 &b)
SFR3 le (const SFR3 &a, const Scalar &b)
SFR3 le (const Scalar &a, const SFR3 &b)
SFR3 logical_and (const SFR3 &a, const Scalar &b)
SFR3 logical_and (const Scalar &a, const SFR3 &b)
SFR3 logical_or (const SFR3 &a, const Scalar &b)
SFR3 logical_or (const Scalar &a, const SFR3 &b)
SFR3 logical_xor (const SFR3 &a, const Scalar &b)
SFR3 logical_xor (const Scalar &a, const SFR3 &b)
SFR3 eq (const SFR3 &a, const Scalar &b)
SFR3 eq (const Scalar &a, const SFR3 &b)
SFR3 ne (const SFR3 &a, const Scalar &b)
SFR3 ne (const Scalar &a, const SFR3 &b)
R4 operator> (const R4 &a, const Scalar &b)
R4 operator> (const Scalar &a, const R4 &b)
R4 operator< (const R4 &a, const Scalar &b)
R4 operator< (const Scalar &a, const R4 &b)
R4 operator>= (const R4 &a, const Scalar &b)
R4 operator>= (const Scalar &a, const R4 &b)
R4 operator<= (const R4 &a, const Scalar &b)
R4 operator<= (const Scalar &a, const R4 &b)
R4 operator&& (const R4 &a, const Scalar &b)
R4 operator&& (const Scalar &a, const R4 &b)
R4 operator|| (const R4 &a, const Scalar &b)
R4 operator|| (const Scalar &a, const R4 &b)
R4 operator== (const R4 &a, const Scalar &b)
R4 operator== (const Scalar &a, const R4 &b)
R4 operator!= (const R4 &a, const Scalar &b)
R4 operator!= (const Scalar &a, const R4 &b)
R4 gt (const R4 &a, const Scalar &b)
R4 gt (const Scalar &a, const R4 &b)
R4 lt (const R4 &a, const Scalar &b)
R4 lt (const Scalar &a, const R4 &b)
R4 ge (const R4 &a, const Scalar &b)
R4 ge (const Scalar &a, const R4 &b)
R4 le (const R4 &a, const Scalar &b)
R4 le (const Scalar &a, const R4 &b)
R4 logical_and (const R4 &a, const Scalar &b)
R4 logical_and (const Scalar &a, const R4 &b)
R4 logical_or (const R4 &a, const Scalar &b)
R4 logical_or (const Scalar &a, const R4 &b)
R4 logical_xor (const R4 &a, const Scalar &b)
R4 logical_xor (const Scalar &a, const R4 &b)
R4 eq (const R4 &a, const Scalar &b)
R4 eq (const Scalar &a, const R4 &b)
R4 ne (const R4 &a, const Scalar &b)
R4 ne (const Scalar &a, const R4 &b)
SFFR4 operator> (const SFFR4 &a, const Scalar &b)
SFFR4 operator> (const Scalar &a, const SFFR4 &b)
SFFR4 operator< (const SFFR4 &a, const Scalar &b)
SFFR4 operator< (const Scalar &a, const SFFR4 &b)
SFFR4 operator>= (const SFFR4 &a, const Scalar &b)
SFFR4 operator>= (const Scalar &a, const SFFR4 &b)
SFFR4 operator<= (const SFFR4 &a, const Scalar &b)
SFFR4 operator<= (const Scalar &a, const SFFR4 &b)
SFFR4 operator&& (const SFFR4 &a, const Scalar &b)
SFFR4 operator&& (const Scalar &a, const SFFR4 &b)
SFFR4 operator|| (const SFFR4 &a, const Scalar &b)
SFFR4 operator|| (const Scalar &a, const SFFR4 &b)
SFFR4 operator== (const SFFR4 &a, const Scalar &b)
SFFR4 operator== (const Scalar &a, const SFFR4 &b)
SFFR4 operator!= (const SFFR4 &a, const Scalar &b)
SFFR4 operator!= (const Scalar &a, const SFFR4 &b)
SFFR4 gt (const SFFR4 &a, const Scalar &b)
SFFR4 gt (const Scalar &a, const SFFR4 &b)
SFFR4 lt (const SFFR4 &a, const Scalar &b)
SFFR4 lt (const Scalar &a, const SFFR4 &b)
SFFR4 ge (const SFFR4 &a, const Scalar &b)
SFFR4 ge (const Scalar &a, const SFFR4 &b)
SFFR4 le (const SFFR4 &a, const Scalar &b)
SFFR4 le (const Scalar &a, const SFFR4 &b)
SFFR4 logical_and (const SFFR4 &a, const Scalar &b)
SFFR4 logical_and (const Scalar &a, const SFFR4 &b)
SFFR4 logical_or (const SFFR4 &a, const Scalar &b)
SFFR4 logical_or (const Scalar &a, const SFFR4 &b)
SFFR4 logical_xor (const SFFR4 &a, const Scalar &b)
SFFR4 logical_xor (const Scalar &a, const SFFR4 &b)
SFFR4 eq (const SFFR4 &a, const Scalar &b)
SFFR4 eq (const Scalar &a, const SFFR4 &b)
SFFR4 ne (const SFFR4 &a, const Scalar &b)
SFFR4 ne (const Scalar &a, const SFFR4 &b)
WFFR4 operator> (const WFFR4 &a, const Scalar &b)
WFFR4 operator> (const Scalar &a, const WFFR4 &b)
WFFR4 operator< (const WFFR4 &a, const Scalar &b)
WFFR4 operator< (const Scalar &a, const WFFR4 &b)
WFFR4 operator>= (const WFFR4 &a, const Scalar &b)
WFFR4 operator>= (const Scalar &a, const WFFR4 &b)
WFFR4 operator<= (const WFFR4 &a, const Scalar &b)
WFFR4 operator<= (const Scalar &a, const WFFR4 &b)
WFFR4 operator&& (const WFFR4 &a, const Scalar &b)
WFFR4 operator&& (const Scalar &a, const WFFR4 &b)
WFFR4 operator|| (const WFFR4 &a, const Scalar &b)
WFFR4 operator|| (const Scalar &a, const WFFR4 &b)
WFFR4 operator== (const WFFR4 &a, const Scalar &b)
WFFR4 operator== (const Scalar &a, const WFFR4 &b)
WFFR4 operator!= (const WFFR4 &a, const Scalar &b)
WFFR4 operator!= (const Scalar &a, const WFFR4 &b)
WFFR4 gt (const WFFR4 &a, const Scalar &b)
WFFR4 gt (const Scalar &a, const WFFR4 &b)
WFFR4 lt (const WFFR4 &a, const Scalar &b)
WFFR4 lt (const Scalar &a, const WFFR4 &b)
WFFR4 ge (const WFFR4 &a, const Scalar &b)
WFFR4 ge (const Scalar &a, const WFFR4 &b)
WFFR4 le (const WFFR4 &a, const Scalar &b)
WFFR4 le (const Scalar &a, const WFFR4 &b)
WFFR4 logical_and (const WFFR4 &a, const Scalar &b)
WFFR4 logical_and (const Scalar &a, const WFFR4 &b)
WFFR4 logical_or (const WFFR4 &a, const Scalar &b)
WFFR4 logical_or (const Scalar &a, const WFFR4 &b)
WFFR4 logical_xor (const WFFR4 &a, const Scalar &b)
WFFR4 logical_xor (const Scalar &a, const WFFR4 &b)
WFFR4 eq (const WFFR4 &a, const Scalar &b)
WFFR4 eq (const Scalar &a, const WFFR4 &b)
WFFR4 ne (const WFFR4 &a, const Scalar &b)
WFFR4 ne (const Scalar &a, const WFFR4 &b)
SSR4 operator> (const SSR4 &a, const Scalar &b)
SSR4 operator> (const Scalar &a, const SSR4 &b)
SSR4 operator< (const SSR4 &a, const Scalar &b)
SSR4 operator< (const Scalar &a, const SSR4 &b)
SSR4 operator>= (const SSR4 &a, const Scalar &b)
SSR4 operator>= (const Scalar &a, const SSR4 &b)
SSR4 operator<= (const SSR4 &a, const Scalar &b)
SSR4 operator<= (const Scalar &a, const SSR4 &b)
SSR4 operator&& (const SSR4 &a, const Scalar &b)
SSR4 operator&& (const Scalar &a, const SSR4 &b)
SSR4 operator|| (const SSR4 &a, const Scalar &b)
SSR4 operator|| (const Scalar &a, const SSR4 &b)
SSR4 operator== (const SSR4 &a, const Scalar &b)
SSR4 operator== (const Scalar &a, const SSR4 &b)
SSR4 operator!= (const SSR4 &a, const Scalar &b)
SSR4 operator!= (const Scalar &a, const SSR4 &b)
SSR4 gt (const SSR4 &a, const Scalar &b)
SSR4 gt (const Scalar &a, const SSR4 &b)
SSR4 lt (const SSR4 &a, const Scalar &b)
SSR4 lt (const Scalar &a, const SSR4 &b)
SSR4 ge (const SSR4 &a, const Scalar &b)
SSR4 ge (const Scalar &a, const SSR4 &b)
SSR4 le (const SSR4 &a, const Scalar &b)
SSR4 le (const Scalar &a, const SSR4 &b)
SSR4 logical_and (const SSR4 &a, const Scalar &b)
SSR4 logical_and (const Scalar &a, const SSR4 &b)
SSR4 logical_or (const SSR4 &a, const Scalar &b)
SSR4 logical_or (const Scalar &a, const SSR4 &b)
SSR4 logical_xor (const SSR4 &a, const Scalar &b)
SSR4 logical_xor (const Scalar &a, const SSR4 &b)
SSR4 eq (const SSR4 &a, const Scalar &b)
SSR4 eq (const Scalar &a, const SSR4 &b)
SSR4 ne (const SSR4 &a, const Scalar &b)
SSR4 ne (const Scalar &a, const SSR4 &b)
SWR4 operator> (const SWR4 &a, const Scalar &b)
SWR4 operator> (const Scalar &a, const SWR4 &b)
SWR4 operator< (const SWR4 &a, const Scalar &b)
SWR4 operator< (const Scalar &a, const SWR4 &b)
SWR4 operator>= (const SWR4 &a, const Scalar &b)
SWR4 operator>= (const Scalar &a, const SWR4 &b)
SWR4 operator<= (const SWR4 &a, const Scalar &b)
SWR4 operator<= (const Scalar &a, const SWR4 &b)
SWR4 operator&& (const SWR4 &a, const Scalar &b)
SWR4 operator&& (const Scalar &a, const SWR4 &b)
SWR4 operator|| (const SWR4 &a, const Scalar &b)
SWR4 operator|| (const Scalar &a, const SWR4 &b)
SWR4 operator== (const SWR4 &a, const Scalar &b)
SWR4 operator== (const Scalar &a, const SWR4 &b)
SWR4 operator!= (const SWR4 &a, const Scalar &b)
SWR4 operator!= (const Scalar &a, const SWR4 &b)
SWR4 gt (const SWR4 &a, const Scalar &b)
SWR4 gt (const Scalar &a, const SWR4 &b)
SWR4 lt (const SWR4 &a, const Scalar &b)
SWR4 lt (const Scalar &a, const SWR4 &b)
SWR4 ge (const SWR4 &a, const Scalar &b)
SWR4 ge (const Scalar &a, const SWR4 &b)
SWR4 le (const SWR4 &a, const Scalar &b)
SWR4 le (const Scalar &a, const SWR4 &b)
SWR4 logical_and (const SWR4 &a, const Scalar &b)
SWR4 logical_and (const Scalar &a, const SWR4 &b)
SWR4 logical_or (const SWR4 &a, const Scalar &b)
SWR4 logical_or (const Scalar &a, const SWR4 &b)
SWR4 logical_xor (const SWR4 &a, const Scalar &b)
SWR4 logical_xor (const Scalar &a, const SWR4 &b)
SWR4 eq (const SWR4 &a, const Scalar &b)
SWR4 eq (const Scalar &a, const SWR4 &b)
SWR4 ne (const SWR4 &a, const Scalar &b)
SWR4 ne (const Scalar &a, const SWR4 &b)
WSR4 operator> (const WSR4 &a, const Scalar &b)
WSR4 operator> (const Scalar &a, const WSR4 &b)
WSR4 operator< (const WSR4 &a, const Scalar &b)
WSR4 operator< (const Scalar &a, const WSR4 &b)
WSR4 operator>= (const WSR4 &a, const Scalar &b)
WSR4 operator>= (const Scalar &a, const WSR4 &b)
WSR4 operator<= (const WSR4 &a, const Scalar &b)
WSR4 operator<= (const Scalar &a, const WSR4 &b)
WSR4 operator&& (const WSR4 &a, const Scalar &b)
WSR4 operator&& (const Scalar &a, const WSR4 &b)
WSR4 operator|| (const WSR4 &a, const Scalar &b)
WSR4 operator|| (const Scalar &a, const WSR4 &b)
WSR4 operator== (const WSR4 &a, const Scalar &b)
WSR4 operator== (const Scalar &a, const WSR4 &b)
WSR4 operator!= (const WSR4 &a, const Scalar &b)
WSR4 operator!= (const Scalar &a, const WSR4 &b)
WSR4 gt (const WSR4 &a, const Scalar &b)
WSR4 gt (const Scalar &a, const WSR4 &b)
WSR4 lt (const WSR4 &a, const Scalar &b)
WSR4 lt (const Scalar &a, const WSR4 &b)
WSR4 ge (const WSR4 &a, const Scalar &b)
WSR4 ge (const Scalar &a, const WSR4 &b)
WSR4 le (const WSR4 &a, const Scalar &b)
WSR4 le (const Scalar &a, const WSR4 &b)
WSR4 logical_and (const WSR4 &a, const Scalar &b)
WSR4 logical_and (const Scalar &a, const WSR4 &b)
WSR4 logical_or (const WSR4 &a, const Scalar &b)
WSR4 logical_or (const Scalar &a, const WSR4 &b)
WSR4 logical_xor (const WSR4 &a, const Scalar &b)
WSR4 logical_xor (const Scalar &a, const WSR4 &b)
WSR4 eq (const WSR4 &a, const Scalar &b)
WSR4 eq (const Scalar &a, const WSR4 &b)
WSR4 ne (const WSR4 &a, const Scalar &b)
WSR4 ne (const Scalar &a, const WSR4 &b)
WWR4 operator> (const WWR4 &a, const Scalar &b)
WWR4 operator> (const Scalar &a, const WWR4 &b)
WWR4 operator< (const WWR4 &a, const Scalar &b)
WWR4 operator< (const Scalar &a, const WWR4 &b)
WWR4 operator>= (const WWR4 &a, const Scalar &b)
WWR4 operator>= (const Scalar &a, const WWR4 &b)
WWR4 operator<= (const WWR4 &a, const Scalar &b)
WWR4 operator<= (const Scalar &a, const WWR4 &b)
WWR4 operator&& (const WWR4 &a, const Scalar &b)
WWR4 operator&& (const Scalar &a, const WWR4 &b)
WWR4 operator|| (const WWR4 &a, const Scalar &b)
WWR4 operator|| (const Scalar &a, const WWR4 &b)
WWR4 operator== (const WWR4 &a, const Scalar &b)
WWR4 operator== (const Scalar &a, const WWR4 &b)
WWR4 operator!= (const WWR4 &a, const Scalar &b)
WWR4 operator!= (const Scalar &a, const WWR4 &b)
WWR4 gt (const WWR4 &a, const Scalar &b)
WWR4 gt (const Scalar &a, const WWR4 &b)
WWR4 lt (const WWR4 &a, const Scalar &b)
WWR4 lt (const Scalar &a, const WWR4 &b)
WWR4 ge (const WWR4 &a, const Scalar &b)
WWR4 ge (const Scalar &a, const WWR4 &b)
WWR4 le (const WWR4 &a, const Scalar &b)
WWR4 le (const Scalar &a, const WWR4 &b)
WWR4 logical_and (const WWR4 &a, const Scalar &b)
WWR4 logical_and (const Scalar &a, const WWR4 &b)
WWR4 logical_or (const WWR4 &a, const Scalar &b)
WWR4 logical_or (const Scalar &a, const WWR4 &b)
WWR4 logical_xor (const WWR4 &a, const Scalar &b)
WWR4 logical_xor (const Scalar &a, const WWR4 &b)
WWR4 eq (const WWR4 &a, const Scalar &b)
WWR4 eq (const Scalar &a, const WWR4 &b)
WWR4 ne (const WWR4 &a, const Scalar &b)
WWR4 ne (const Scalar &a, const WWR4 &b)
Quaternion operator> (const Quaternion &a, const Scalar &b)
Quaternion operator> (const Scalar &a, const Quaternion &b)
Quaternion operator< (const Quaternion &a, const Scalar &b)
Quaternion operator< (const Scalar &a, const Quaternion &b)
Quaternion operator>= (const Quaternion &a, const Scalar &b)
Quaternion operator>= (const Scalar &a, const Quaternion &b)
Quaternion operator<= (const Quaternion &a, const Scalar &b)
Quaternion operator<= (const Scalar &a, const Quaternion &b)
Quaternion operator&& (const Quaternion &a, const Scalar &b)
Quaternion operator&& (const Scalar &a, const Quaternion &b)
Quaternion operator|| (const Quaternion &a, const Scalar &b)
Quaternion operator|| (const Scalar &a, const Quaternion &b)
Quaternion operator== (const Quaternion &a, const Scalar &b)
Quaternion operator== (const Scalar &a, const Quaternion &b)
Quaternion operator!= (const Quaternion &a, const Scalar &b)
Quaternion operator!= (const Scalar &a, const Quaternion &b)
Quaternion gt (const Quaternion &a, const Scalar &b)
Quaternion gt (const Scalar &a, const Quaternion &b)
Quaternion lt (const Quaternion &a, const Scalar &b)
Quaternion lt (const Scalar &a, const Quaternion &b)
Quaternion ge (const Quaternion &a, const Scalar &b)
Quaternion ge (const Scalar &a, const Quaternion &b)
Quaternion le (const Quaternion &a, const Scalar &b)
Quaternion le (const Scalar &a, const Quaternion &b)
Quaternion logical_and (const Quaternion &a, const Scalar &b)
Quaternion logical_and (const Scalar &a, const Quaternion &b)
Quaternion logical_or (const Quaternion &a, const Scalar &b)
Quaternion logical_or (const Scalar &a, const Quaternion &b)
Quaternion logical_xor (const Quaternion &a, const Scalar &b)
Quaternion logical_xor (const Scalar &a, const Quaternion &b)
Quaternion eq (const Quaternion &a, const Scalar &b)
Quaternion eq (const Scalar &a, const Quaternion &b)
Quaternion ne (const Quaternion &a, const Scalar &b)
Quaternion ne (const Scalar &a, const Quaternion &b)
MillerIndex operator> (const MillerIndex &a, const Scalar &b)
MillerIndex operator> (const Scalar &a, const MillerIndex &b)
MillerIndex operator< (const MillerIndex &a, const Scalar &b)
MillerIndex operator< (const Scalar &a, const MillerIndex &b)
MillerIndex operator>= (const MillerIndex &a, const Scalar &b)
MillerIndex operator>= (const Scalar &a, const MillerIndex &b)
MillerIndex operator<= (const MillerIndex &a, const Scalar &b)
MillerIndex operator<= (const Scalar &a, const MillerIndex &b)
MillerIndex operator&& (const MillerIndex &a, const Scalar &b)
MillerIndex operator&& (const Scalar &a, const MillerIndex &b)
MillerIndex operator|| (const MillerIndex &a, const Scalar &b)
MillerIndex operator|| (const Scalar &a, const MillerIndex &b)
MillerIndex operator== (const MillerIndex &a, const Scalar &b)
MillerIndex operator== (const Scalar &a, const MillerIndex &b)
MillerIndex operator!= (const MillerIndex &a, const Scalar &b)
MillerIndex operator!= (const Scalar &a, const MillerIndex &b)
MillerIndex gt (const MillerIndex &a, const Scalar &b)
MillerIndex gt (const Scalar &a, const MillerIndex &b)
MillerIndex lt (const MillerIndex &a, const Scalar &b)
MillerIndex lt (const Scalar &a, const MillerIndex &b)
MillerIndex ge (const MillerIndex &a, const Scalar &b)
MillerIndex ge (const Scalar &a, const MillerIndex &b)
MillerIndex le (const MillerIndex &a, const Scalar &b)
MillerIndex le (const Scalar &a, const MillerIndex &b)
MillerIndex logical_and (const MillerIndex &a, const Scalar &b)
MillerIndex logical_and (const Scalar &a, const MillerIndex &b)
MillerIndex logical_or (const MillerIndex &a, const Scalar &b)
MillerIndex logical_or (const Scalar &a, const MillerIndex &b)
MillerIndex logical_xor (const MillerIndex &a, const Scalar &b)
MillerIndex logical_xor (const Scalar &a, const MillerIndex &b)
MillerIndex eq (const MillerIndex &a, const Scalar &b)
MillerIndex eq (const Scalar &a, const MillerIndex &b)
MillerIndex ne (const MillerIndex &a, const Scalar &b)
MillerIndex ne (const Scalar &a, const MillerIndex &b)
Vec operator> (const Vec &a, const CScalar &b)
Vec operator> (const CScalar &a, const Vec &b)
Vec operator< (const Vec &a, const CScalar &b)
Vec operator< (const CScalar &a, const Vec &b)
Vec operator>= (const Vec &a, const CScalar &b)
Vec operator>= (const CScalar &a, const Vec &b)
Vec operator<= (const Vec &a, const CScalar &b)
Vec operator<= (const CScalar &a, const Vec &b)
Vec operator&& (const Vec &a, const CScalar &b)
Vec operator&& (const CScalar &a, const Vec &b)
Vec operator|| (const Vec &a, const CScalar &b)
Vec operator|| (const CScalar &a, const Vec &b)
Vec operator== (const Vec &a, const CScalar &b)
Vec operator== (const CScalar &a, const Vec &b)
Vec operator!= (const Vec &a, const CScalar &b)
Vec operator!= (const CScalar &a, const Vec &b)
Vec gt (const Vec &a, const CScalar &b)
Vec gt (const CScalar &a, const Vec &b)
Vec lt (const Vec &a, const CScalar &b)
Vec lt (const CScalar &a, const Vec &b)
Vec ge (const Vec &a, const CScalar &b)
Vec ge (const CScalar &a, const Vec &b)
Vec le (const Vec &a, const CScalar &b)
Vec le (const CScalar &a, const Vec &b)
Vec logical_and (const Vec &a, const CScalar &b)
Vec logical_and (const CScalar &a, const Vec &b)
Vec logical_or (const Vec &a, const CScalar &b)
Vec logical_or (const CScalar &a, const Vec &b)
Vec logical_xor (const Vec &a, const CScalar &b)
Vec logical_xor (const CScalar &a, const Vec &b)
Vec eq (const Vec &a, const CScalar &b)
Vec eq (const CScalar &a, const Vec &b)
Vec ne (const Vec &a, const CScalar &b)
Vec ne (const CScalar &a, const Vec &b)
Rot operator> (const Rot &a, const CScalar &b)
Rot operator> (const CScalar &a, const Rot &b)
Rot operator< (const Rot &a, const CScalar &b)
Rot operator< (const CScalar &a, const Rot &b)
Rot operator>= (const Rot &a, const CScalar &b)
Rot operator>= (const CScalar &a, const Rot &b)
Rot operator<= (const Rot &a, const CScalar &b)
Rot operator<= (const CScalar &a, const Rot &b)
Rot operator&& (const Rot &a, const CScalar &b)
Rot operator&& (const CScalar &a, const Rot &b)
Rot operator|| (const Rot &a, const CScalar &b)
Rot operator|| (const CScalar &a, const Rot &b)
Rot operator== (const Rot &a, const CScalar &b)
Rot operator== (const CScalar &a, const Rot &b)
Rot operator!= (const Rot &a, const CScalar &b)
Rot operator!= (const CScalar &a, const Rot &b)
Rot gt (const Rot &a, const CScalar &b)
Rot gt (const CScalar &a, const Rot &b)
Rot lt (const Rot &a, const CScalar &b)
Rot lt (const CScalar &a, const Rot &b)
Rot ge (const Rot &a, const CScalar &b)
Rot ge (const CScalar &a, const Rot &b)
Rot le (const Rot &a, const CScalar &b)
Rot le (const CScalar &a, const Rot &b)
Rot logical_and (const Rot &a, const CScalar &b)
Rot logical_and (const CScalar &a, const Rot &b)
Rot logical_or (const Rot &a, const CScalar &b)
Rot logical_or (const CScalar &a, const Rot &b)
Rot logical_xor (const Rot &a, const CScalar &b)
Rot logical_xor (const CScalar &a, const Rot &b)
Rot eq (const Rot &a, const CScalar &b)
Rot eq (const CScalar &a, const Rot &b)
Rot ne (const Rot &a, const CScalar &b)
Rot ne (const CScalar &a, const Rot &b)
WR2 operator> (const WR2 &a, const CScalar &b)
WR2 operator> (const CScalar &a, const WR2 &b)
WR2 operator< (const WR2 &a, const CScalar &b)
WR2 operator< (const CScalar &a, const WR2 &b)
WR2 operator>= (const WR2 &a, const CScalar &b)
WR2 operator>= (const CScalar &a, const WR2 &b)
WR2 operator<= (const WR2 &a, const CScalar &b)
WR2 operator<= (const CScalar &a, const WR2 &b)
WR2 operator&& (const WR2 &a, const CScalar &b)
WR2 operator&& (const CScalar &a, const WR2 &b)
WR2 operator|| (const WR2 &a, const CScalar &b)
WR2 operator|| (const CScalar &a, const WR2 &b)
WR2 operator== (const WR2 &a, const CScalar &b)
WR2 operator== (const CScalar &a, const WR2 &b)
WR2 operator!= (const WR2 &a, const CScalar &b)
WR2 operator!= (const CScalar &a, const WR2 &b)
WR2 gt (const WR2 &a, const CScalar &b)
WR2 gt (const CScalar &a, const WR2 &b)
WR2 lt (const WR2 &a, const CScalar &b)
WR2 lt (const CScalar &a, const WR2 &b)
WR2 ge (const WR2 &a, const CScalar &b)
WR2 ge (const CScalar &a, const WR2 &b)
WR2 le (const WR2 &a, const CScalar &b)
WR2 le (const CScalar &a, const WR2 &b)
WR2 logical_and (const WR2 &a, const CScalar &b)
WR2 logical_and (const CScalar &a, const WR2 &b)
WR2 logical_or (const WR2 &a, const CScalar &b)
WR2 logical_or (const CScalar &a, const WR2 &b)
WR2 logical_xor (const WR2 &a, const CScalar &b)
WR2 logical_xor (const CScalar &a, const WR2 &b)
WR2 eq (const WR2 &a, const CScalar &b)
WR2 eq (const CScalar &a, const WR2 &b)
WR2 ne (const WR2 &a, const CScalar &b)
WR2 ne (const CScalar &a, const WR2 &b)
R2 operator> (const R2 &a, const CScalar &b)
R2 operator> (const CScalar &a, const R2 &b)
R2 operator< (const R2 &a, const CScalar &b)
R2 operator< (const CScalar &a, const R2 &b)
R2 operator>= (const R2 &a, const CScalar &b)
R2 operator>= (const CScalar &a, const R2 &b)
R2 operator<= (const R2 &a, const CScalar &b)
R2 operator<= (const CScalar &a, const R2 &b)
R2 operator&& (const R2 &a, const CScalar &b)
R2 operator&& (const CScalar &a, const R2 &b)
R2 operator|| (const R2 &a, const CScalar &b)
R2 operator|| (const CScalar &a, const R2 &b)
R2 operator== (const R2 &a, const CScalar &b)
R2 operator== (const CScalar &a, const R2 &b)
R2 operator!= (const R2 &a, const CScalar &b)
R2 operator!= (const CScalar &a, const R2 &b)
R2 gt (const R2 &a, const CScalar &b)
R2 gt (const CScalar &a, const R2 &b)
R2 lt (const R2 &a, const CScalar &b)
R2 lt (const CScalar &a, const R2 &b)
R2 ge (const R2 &a, const CScalar &b)
R2 ge (const CScalar &a, const R2 &b)
R2 le (const R2 &a, const CScalar &b)
R2 le (const CScalar &a, const R2 &b)
R2 logical_and (const R2 &a, const CScalar &b)
R2 logical_and (const CScalar &a, const R2 &b)
R2 logical_or (const R2 &a, const CScalar &b)
R2 logical_or (const CScalar &a, const R2 &b)
R2 logical_xor (const R2 &a, const CScalar &b)
R2 logical_xor (const CScalar &a, const R2 &b)
R2 eq (const R2 &a, const CScalar &b)
R2 eq (const CScalar &a, const R2 &b)
R2 ne (const R2 &a, const CScalar &b)
R2 ne (const CScalar &a, const R2 &b)
SR2 operator> (const SR2 &a, const CScalar &b)
SR2 operator> (const CScalar &a, const SR2 &b)
SR2 operator< (const SR2 &a, const CScalar &b)
SR2 operator< (const CScalar &a, const SR2 &b)
SR2 operator>= (const SR2 &a, const CScalar &b)
SR2 operator>= (const CScalar &a, const SR2 &b)
SR2 operator<= (const SR2 &a, const CScalar &b)
SR2 operator<= (const CScalar &a, const SR2 &b)
SR2 operator&& (const SR2 &a, const CScalar &b)
SR2 operator&& (const CScalar &a, const SR2 &b)
SR2 operator|| (const SR2 &a, const CScalar &b)
SR2 operator|| (const CScalar &a, const SR2 &b)
SR2 operator== (const SR2 &a, const CScalar &b)
SR2 operator== (const CScalar &a, const SR2 &b)
SR2 operator!= (const SR2 &a, const CScalar &b)
SR2 operator!= (const CScalar &a, const SR2 &b)
SR2 gt (const SR2 &a, const CScalar &b)
SR2 gt (const CScalar &a, const SR2 &b)
SR2 lt (const SR2 &a, const CScalar &b)
SR2 lt (const CScalar &a, const SR2 &b)
SR2 ge (const SR2 &a, const CScalar &b)
SR2 ge (const CScalar &a, const SR2 &b)
SR2 le (const SR2 &a, const CScalar &b)
SR2 le (const CScalar &a, const SR2 &b)
SR2 logical_and (const SR2 &a, const CScalar &b)
SR2 logical_and (const CScalar &a, const SR2 &b)
SR2 logical_or (const SR2 &a, const CScalar &b)
SR2 logical_or (const CScalar &a, const SR2 &b)
SR2 logical_xor (const SR2 &a, const CScalar &b)
SR2 logical_xor (const CScalar &a, const SR2 &b)
SR2 eq (const SR2 &a, const CScalar &b)
SR2 eq (const CScalar &a, const SR2 &b)
SR2 ne (const SR2 &a, const CScalar &b)
SR2 ne (const CScalar &a, const SR2 &b)
R3 operator> (const R3 &a, const CScalar &b)
R3 operator> (const CScalar &a, const R3 &b)
R3 operator< (const R3 &a, const CScalar &b)
R3 operator< (const CScalar &a, const R3 &b)
R3 operator>= (const R3 &a, const CScalar &b)
R3 operator>= (const CScalar &a, const R3 &b)
R3 operator<= (const R3 &a, const CScalar &b)
R3 operator<= (const CScalar &a, const R3 &b)
R3 operator&& (const R3 &a, const CScalar &b)
R3 operator&& (const CScalar &a, const R3 &b)
R3 operator|| (const R3 &a, const CScalar &b)
R3 operator|| (const CScalar &a, const R3 &b)
R3 operator== (const R3 &a, const CScalar &b)
R3 operator== (const CScalar &a, const R3 &b)
R3 operator!= (const R3 &a, const CScalar &b)
R3 operator!= (const CScalar &a, const R3 &b)
R3 gt (const R3 &a, const CScalar &b)
R3 gt (const CScalar &a, const R3 &b)
R3 lt (const R3 &a, const CScalar &b)
R3 lt (const CScalar &a, const R3 &b)
R3 ge (const R3 &a, const CScalar &b)
R3 ge (const CScalar &a, const R3 &b)
R3 le (const R3 &a, const CScalar &b)
R3 le (const CScalar &a, const R3 &b)
R3 logical_and (const R3 &a, const CScalar &b)
R3 logical_and (const CScalar &a, const R3 &b)
R3 logical_or (const R3 &a, const CScalar &b)
R3 logical_or (const CScalar &a, const R3 &b)
R3 logical_xor (const R3 &a, const CScalar &b)
R3 logical_xor (const CScalar &a, const R3 &b)
R3 eq (const R3 &a, const CScalar &b)
R3 eq (const CScalar &a, const R3 &b)
R3 ne (const R3 &a, const CScalar &b)
R3 ne (const CScalar &a, const R3 &b)
SFR3 operator> (const SFR3 &a, const CScalar &b)
SFR3 operator> (const CScalar &a, const SFR3 &b)
SFR3 operator< (const SFR3 &a, const CScalar &b)
SFR3 operator< (const CScalar &a, const SFR3 &b)
SFR3 operator>= (const SFR3 &a, const CScalar &b)
SFR3 operator>= (const CScalar &a, const SFR3 &b)
SFR3 operator<= (const SFR3 &a, const CScalar &b)
SFR3 operator<= (const CScalar &a, const SFR3 &b)
SFR3 operator&& (const SFR3 &a, const CScalar &b)
SFR3 operator&& (const CScalar &a, const SFR3 &b)
SFR3 operator|| (const SFR3 &a, const CScalar &b)
SFR3 operator|| (const CScalar &a, const SFR3 &b)
SFR3 operator== (const SFR3 &a, const CScalar &b)
SFR3 operator== (const CScalar &a, const SFR3 &b)
SFR3 operator!= (const SFR3 &a, const CScalar &b)
SFR3 operator!= (const CScalar &a, const SFR3 &b)
SFR3 gt (const SFR3 &a, const CScalar &b)
SFR3 gt (const CScalar &a, const SFR3 &b)
SFR3 lt (const SFR3 &a, const CScalar &b)
SFR3 lt (const CScalar &a, const SFR3 &b)
SFR3 ge (const SFR3 &a, const CScalar &b)
SFR3 ge (const CScalar &a, const SFR3 &b)
SFR3 le (const SFR3 &a, const CScalar &b)
SFR3 le (const CScalar &a, const SFR3 &b)
SFR3 logical_and (const SFR3 &a, const CScalar &b)
SFR3 logical_and (const CScalar &a, const SFR3 &b)
SFR3 logical_or (const SFR3 &a, const CScalar &b)
SFR3 logical_or (const CScalar &a, const SFR3 &b)
SFR3 logical_xor (const SFR3 &a, const CScalar &b)
SFR3 logical_xor (const CScalar &a, const SFR3 &b)
SFR3 eq (const SFR3 &a, const CScalar &b)
SFR3 eq (const CScalar &a, const SFR3 &b)
SFR3 ne (const SFR3 &a, const CScalar &b)
SFR3 ne (const CScalar &a, const SFR3 &b)
R4 operator> (const R4 &a, const CScalar &b)
R4 operator> (const CScalar &a, const R4 &b)
R4 operator< (const R4 &a, const CScalar &b)
R4 operator< (const CScalar &a, const R4 &b)
R4 operator>= (const R4 &a, const CScalar &b)
R4 operator>= (const CScalar &a, const R4 &b)
R4 operator<= (const R4 &a, const CScalar &b)
R4 operator<= (const CScalar &a, const R4 &b)
R4 operator&& (const R4 &a, const CScalar &b)
R4 operator&& (const CScalar &a, const R4 &b)
R4 operator|| (const R4 &a, const CScalar &b)
R4 operator|| (const CScalar &a, const R4 &b)
R4 operator== (const R4 &a, const CScalar &b)
R4 operator== (const CScalar &a, const R4 &b)
R4 operator!= (const R4 &a, const CScalar &b)
R4 operator!= (const CScalar &a, const R4 &b)
R4 gt (const R4 &a, const CScalar &b)
R4 gt (const CScalar &a, const R4 &b)
R4 lt (const R4 &a, const CScalar &b)
R4 lt (const CScalar &a, const R4 &b)
R4 ge (const R4 &a, const CScalar &b)
R4 ge (const CScalar &a, const R4 &b)
R4 le (const R4 &a, const CScalar &b)
R4 le (const CScalar &a, const R4 &b)
R4 logical_and (const R4 &a, const CScalar &b)
R4 logical_and (const CScalar &a, const R4 &b)
R4 logical_or (const R4 &a, const CScalar &b)
R4 logical_or (const CScalar &a, const R4 &b)
R4 logical_xor (const R4 &a, const CScalar &b)
R4 logical_xor (const CScalar &a, const R4 &b)
R4 eq (const R4 &a, const CScalar &b)
R4 eq (const CScalar &a, const R4 &b)
R4 ne (const R4 &a, const CScalar &b)
R4 ne (const CScalar &a, const R4 &b)
SFFR4 operator> (const SFFR4 &a, const CScalar &b)
SFFR4 operator> (const CScalar &a, const SFFR4 &b)
SFFR4 operator< (const SFFR4 &a, const CScalar &b)
SFFR4 operator< (const CScalar &a, const SFFR4 &b)
SFFR4 operator>= (const SFFR4 &a, const CScalar &b)
SFFR4 operator>= (const CScalar &a, const SFFR4 &b)
SFFR4 operator<= (const SFFR4 &a, const CScalar &b)
SFFR4 operator<= (const CScalar &a, const SFFR4 &b)
SFFR4 operator&& (const SFFR4 &a, const CScalar &b)
SFFR4 operator&& (const CScalar &a, const SFFR4 &b)
SFFR4 operator|| (const SFFR4 &a, const CScalar &b)
SFFR4 operator|| (const CScalar &a, const SFFR4 &b)
SFFR4 operator== (const SFFR4 &a, const CScalar &b)
SFFR4 operator== (const CScalar &a, const SFFR4 &b)
SFFR4 operator!= (const SFFR4 &a, const CScalar &b)
SFFR4 operator!= (const CScalar &a, const SFFR4 &b)
SFFR4 gt (const SFFR4 &a, const CScalar &b)
SFFR4 gt (const CScalar &a, const SFFR4 &b)
SFFR4 lt (const SFFR4 &a, const CScalar &b)
SFFR4 lt (const CScalar &a, const SFFR4 &b)
SFFR4 ge (const SFFR4 &a, const CScalar &b)
SFFR4 ge (const CScalar &a, const SFFR4 &b)
SFFR4 le (const SFFR4 &a, const CScalar &b)
SFFR4 le (const CScalar &a, const SFFR4 &b)
SFFR4 logical_and (const SFFR4 &a, const CScalar &b)
SFFR4 logical_and (const CScalar &a, const SFFR4 &b)
SFFR4 logical_or (const SFFR4 &a, const CScalar &b)
SFFR4 logical_or (const CScalar &a, const SFFR4 &b)
SFFR4 logical_xor (const SFFR4 &a, const CScalar &b)
SFFR4 logical_xor (const CScalar &a, const SFFR4 &b)
SFFR4 eq (const SFFR4 &a, const CScalar &b)
SFFR4 eq (const CScalar &a, const SFFR4 &b)
SFFR4 ne (const SFFR4 &a, const CScalar &b)
SFFR4 ne (const CScalar &a, const SFFR4 &b)
WFFR4 operator> (const WFFR4 &a, const CScalar &b)
WFFR4 operator> (const CScalar &a, const WFFR4 &b)
WFFR4 operator< (const WFFR4 &a, const CScalar &b)
WFFR4 operator< (const CScalar &a, const WFFR4 &b)
WFFR4 operator>= (const WFFR4 &a, const CScalar &b)
WFFR4 operator>= (const CScalar &a, const WFFR4 &b)
WFFR4 operator<= (const WFFR4 &a, const CScalar &b)
WFFR4 operator<= (const CScalar &a, const WFFR4 &b)
WFFR4 operator&& (const WFFR4 &a, const CScalar &b)
WFFR4 operator&& (const CScalar &a, const WFFR4 &b)
WFFR4 operator|| (const WFFR4 &a, const CScalar &b)
WFFR4 operator|| (const CScalar &a, const WFFR4 &b)
WFFR4 operator== (const WFFR4 &a, const CScalar &b)
WFFR4 operator== (const CScalar &a, const WFFR4 &b)
WFFR4 operator!= (const WFFR4 &a, const CScalar &b)
WFFR4 operator!= (const CScalar &a, const WFFR4 &b)
WFFR4 gt (const WFFR4 &a, const CScalar &b)
WFFR4 gt (const CScalar &a, const WFFR4 &b)
WFFR4 lt (const WFFR4 &a, const CScalar &b)
WFFR4 lt (const CScalar &a, const WFFR4 &b)
WFFR4 ge (const WFFR4 &a, const CScalar &b)
WFFR4 ge (const CScalar &a, const WFFR4 &b)
WFFR4 le (const WFFR4 &a, const CScalar &b)
WFFR4 le (const CScalar &a, const WFFR4 &b)
WFFR4 logical_and (const WFFR4 &a, const CScalar &b)
WFFR4 logical_and (const CScalar &a, const WFFR4 &b)
WFFR4 logical_or (const WFFR4 &a, const CScalar &b)
WFFR4 logical_or (const CScalar &a, const WFFR4 &b)
WFFR4 logical_xor (const WFFR4 &a, const CScalar &b)
WFFR4 logical_xor (const CScalar &a, const WFFR4 &b)
WFFR4 eq (const WFFR4 &a, const CScalar &b)
WFFR4 eq (const CScalar &a, const WFFR4 &b)
WFFR4 ne (const WFFR4 &a, const CScalar &b)
WFFR4 ne (const CScalar &a, const WFFR4 &b)
SSR4 operator> (const SSR4 &a, const CScalar &b)
SSR4 operator> (const CScalar &a, const SSR4 &b)
SSR4 operator< (const SSR4 &a, const CScalar &b)
SSR4 operator< (const CScalar &a, const SSR4 &b)
SSR4 operator>= (const SSR4 &a, const CScalar &b)
SSR4 operator>= (const CScalar &a, const SSR4 &b)
SSR4 operator<= (const SSR4 &a, const CScalar &b)
SSR4 operator<= (const CScalar &a, const SSR4 &b)
SSR4 operator&& (const SSR4 &a, const CScalar &b)
SSR4 operator&& (const CScalar &a, const SSR4 &b)
SSR4 operator|| (const SSR4 &a, const CScalar &b)
SSR4 operator|| (const CScalar &a, const SSR4 &b)
SSR4 operator== (const SSR4 &a, const CScalar &b)
SSR4 operator== (const CScalar &a, const SSR4 &b)
SSR4 operator!= (const SSR4 &a, const CScalar &b)
SSR4 operator!= (const CScalar &a, const SSR4 &b)
SSR4 gt (const SSR4 &a, const CScalar &b)
SSR4 gt (const CScalar &a, const SSR4 &b)
SSR4 lt (const SSR4 &a, const CScalar &b)
SSR4 lt (const CScalar &a, const SSR4 &b)
SSR4 ge (const SSR4 &a, const CScalar &b)
SSR4 ge (const CScalar &a, const SSR4 &b)
SSR4 le (const SSR4 &a, const CScalar &b)
SSR4 le (const CScalar &a, const SSR4 &b)
SSR4 logical_and (const SSR4 &a, const CScalar &b)
SSR4 logical_and (const CScalar &a, const SSR4 &b)
SSR4 logical_or (const SSR4 &a, const CScalar &b)
SSR4 logical_or (const CScalar &a, const SSR4 &b)
SSR4 logical_xor (const SSR4 &a, const CScalar &b)
SSR4 logical_xor (const CScalar &a, const SSR4 &b)
SSR4 eq (const SSR4 &a, const CScalar &b)
SSR4 eq (const CScalar &a, const SSR4 &b)
SSR4 ne (const SSR4 &a, const CScalar &b)
SSR4 ne (const CScalar &a, const SSR4 &b)
SWR4 operator> (const SWR4 &a, const CScalar &b)
SWR4 operator> (const CScalar &a, const SWR4 &b)
SWR4 operator< (const SWR4 &a, const CScalar &b)
SWR4 operator< (const CScalar &a, const SWR4 &b)
SWR4 operator>= (const SWR4 &a, const CScalar &b)
SWR4 operator>= (const CScalar &a, const SWR4 &b)
SWR4 operator<= (const SWR4 &a, const CScalar &b)
SWR4 operator<= (const CScalar &a, const SWR4 &b)
SWR4 operator&& (const SWR4 &a, const CScalar &b)
SWR4 operator&& (const CScalar &a, const SWR4 &b)
SWR4 operator|| (const SWR4 &a, const CScalar &b)
SWR4 operator|| (const CScalar &a, const SWR4 &b)
SWR4 operator== (const SWR4 &a, const CScalar &b)
SWR4 operator== (const CScalar &a, const SWR4 &b)
SWR4 operator!= (const SWR4 &a, const CScalar &b)
SWR4 operator!= (const CScalar &a, const SWR4 &b)
SWR4 gt (const SWR4 &a, const CScalar &b)
SWR4 gt (const CScalar &a, const SWR4 &b)
SWR4 lt (const SWR4 &a, const CScalar &b)
SWR4 lt (const CScalar &a, const SWR4 &b)
SWR4 ge (const SWR4 &a, const CScalar &b)
SWR4 ge (const CScalar &a, const SWR4 &b)
SWR4 le (const SWR4 &a, const CScalar &b)
SWR4 le (const CScalar &a, const SWR4 &b)
SWR4 logical_and (const SWR4 &a, const CScalar &b)
SWR4 logical_and (const CScalar &a, const SWR4 &b)
SWR4 logical_or (const SWR4 &a, const CScalar &b)
SWR4 logical_or (const CScalar &a, const SWR4 &b)
SWR4 logical_xor (const SWR4 &a, const CScalar &b)
SWR4 logical_xor (const CScalar &a, const SWR4 &b)
SWR4 eq (const SWR4 &a, const CScalar &b)
SWR4 eq (const CScalar &a, const SWR4 &b)
SWR4 ne (const SWR4 &a, const CScalar &b)
SWR4 ne (const CScalar &a, const SWR4 &b)
WSR4 operator> (const WSR4 &a, const CScalar &b)
WSR4 operator> (const CScalar &a, const WSR4 &b)
WSR4 operator< (const WSR4 &a, const CScalar &b)
WSR4 operator< (const CScalar &a, const WSR4 &b)
WSR4 operator>= (const WSR4 &a, const CScalar &b)
WSR4 operator>= (const CScalar &a, const WSR4 &b)
WSR4 operator<= (const WSR4 &a, const CScalar &b)
WSR4 operator<= (const CScalar &a, const WSR4 &b)
WSR4 operator&& (const WSR4 &a, const CScalar &b)
WSR4 operator&& (const CScalar &a, const WSR4 &b)
WSR4 operator|| (const WSR4 &a, const CScalar &b)
WSR4 operator|| (const CScalar &a, const WSR4 &b)
WSR4 operator== (const WSR4 &a, const CScalar &b)
WSR4 operator== (const CScalar &a, const WSR4 &b)
WSR4 operator!= (const WSR4 &a, const CScalar &b)
WSR4 operator!= (const CScalar &a, const WSR4 &b)
WSR4 gt (const WSR4 &a, const CScalar &b)
WSR4 gt (const CScalar &a, const WSR4 &b)
WSR4 lt (const WSR4 &a, const CScalar &b)
WSR4 lt (const CScalar &a, const WSR4 &b)
WSR4 ge (const WSR4 &a, const CScalar &b)
WSR4 ge (const CScalar &a, const WSR4 &b)
WSR4 le (const WSR4 &a, const CScalar &b)
WSR4 le (const CScalar &a, const WSR4 &b)
WSR4 logical_and (const WSR4 &a, const CScalar &b)
WSR4 logical_and (const CScalar &a, const WSR4 &b)
WSR4 logical_or (const WSR4 &a, const CScalar &b)
WSR4 logical_or (const CScalar &a, const WSR4 &b)
WSR4 logical_xor (const WSR4 &a, const CScalar &b)
WSR4 logical_xor (const CScalar &a, const WSR4 &b)
WSR4 eq (const WSR4 &a, const CScalar &b)
WSR4 eq (const CScalar &a, const WSR4 &b)
WSR4 ne (const WSR4 &a, const CScalar &b)
WSR4 ne (const CScalar &a, const WSR4 &b)
WWR4 operator> (const WWR4 &a, const CScalar &b)
WWR4 operator> (const CScalar &a, const WWR4 &b)
WWR4 operator< (const WWR4 &a, const CScalar &b)
WWR4 operator< (const CScalar &a, const WWR4 &b)
WWR4 operator>= (const WWR4 &a, const CScalar &b)
WWR4 operator>= (const CScalar &a, const WWR4 &b)
WWR4 operator<= (const WWR4 &a, const CScalar &b)
WWR4 operator<= (const CScalar &a, const WWR4 &b)
WWR4 operator&& (const WWR4 &a, const CScalar &b)
WWR4 operator&& (const CScalar &a, const WWR4 &b)
WWR4 operator|| (const WWR4 &a, const CScalar &b)
WWR4 operator|| (const CScalar &a, const WWR4 &b)
WWR4 operator== (const WWR4 &a, const CScalar &b)
WWR4 operator== (const CScalar &a, const WWR4 &b)
WWR4 operator!= (const WWR4 &a, const CScalar &b)
WWR4 operator!= (const CScalar &a, const WWR4 &b)
WWR4 gt (const WWR4 &a, const CScalar &b)
WWR4 gt (const CScalar &a, const WWR4 &b)
WWR4 lt (const WWR4 &a, const CScalar &b)
WWR4 lt (const CScalar &a, const WWR4 &b)
WWR4 ge (const WWR4 &a, const CScalar &b)
WWR4 ge (const CScalar &a, const WWR4 &b)
WWR4 le (const WWR4 &a, const CScalar &b)
WWR4 le (const CScalar &a, const WWR4 &b)
WWR4 logical_and (const WWR4 &a, const CScalar &b)
WWR4 logical_and (const CScalar &a, const WWR4 &b)
WWR4 logical_or (const WWR4 &a, const CScalar &b)
WWR4 logical_or (const CScalar &a, const WWR4 &b)
WWR4 logical_xor (const WWR4 &a, const CScalar &b)
WWR4 logical_xor (const CScalar &a, const WWR4 &b)
WWR4 eq (const WWR4 &a, const CScalar &b)
WWR4 eq (const CScalar &a, const WWR4 &b)
WWR4 ne (const WWR4 &a, const CScalar &b)
WWR4 ne (const CScalar &a, const WWR4 &b)
Quaternion operator> (const Quaternion &a, const CScalar &b)
Quaternion operator> (const CScalar &a, const Quaternion &b)
Quaternion operator< (const Quaternion &a, const CScalar &b)
Quaternion operator< (const CScalar &a, const Quaternion &b)
Quaternion operator>= (const Quaternion &a, const CScalar &b)
Quaternion operator>= (const CScalar &a, const Quaternion &b)
Quaternion operator<= (const Quaternion &a, const CScalar &b)
Quaternion operator<= (const CScalar &a, const Quaternion &b)
Quaternion operator&& (const Quaternion &a, const CScalar &b)
Quaternion operator&& (const CScalar &a, const Quaternion &b)
Quaternion operator|| (const Quaternion &a, const CScalar &b)
Quaternion operator|| (const CScalar &a, const Quaternion &b)
Quaternion operator== (const Quaternion &a, const CScalar &b)
Quaternion operator== (const CScalar &a, const Quaternion &b)
Quaternion operator!= (const Quaternion &a, const CScalar &b)
Quaternion operator!= (const CScalar &a, const Quaternion &b)
Quaternion gt (const Quaternion &a, const CScalar &b)
Quaternion gt (const CScalar &a, const Quaternion &b)
Quaternion lt (const Quaternion &a, const CScalar &b)
Quaternion lt (const CScalar &a, const Quaternion &b)
Quaternion ge (const Quaternion &a, const CScalar &b)
Quaternion ge (const CScalar &a, const Quaternion &b)
Quaternion le (const Quaternion &a, const CScalar &b)
Quaternion le (const CScalar &a, const Quaternion &b)
Quaternion logical_and (const Quaternion &a, const CScalar &b)
Quaternion logical_and (const CScalar &a, const Quaternion &b)
Quaternion logical_or (const Quaternion &a, const CScalar &b)
Quaternion logical_or (const CScalar &a, const Quaternion &b)
Quaternion logical_xor (const Quaternion &a, const CScalar &b)
Quaternion logical_xor (const CScalar &a, const Quaternion &b)
Quaternion eq (const Quaternion &a, const CScalar &b)
Quaternion eq (const CScalar &a, const Quaternion &b)
Quaternion ne (const Quaternion &a, const CScalar &b)
Quaternion ne (const CScalar &a, const Quaternion &b)
MillerIndex operator> (const MillerIndex &a, const CScalar &b)
MillerIndex operator> (const CScalar &a, const MillerIndex &b)
MillerIndex operator< (const MillerIndex &a, const CScalar &b)
MillerIndex operator< (const CScalar &a, const MillerIndex &b)
MillerIndex operator>= (const MillerIndex &a, const CScalar &b)
MillerIndex operator>= (const CScalar &a, const MillerIndex &b)
MillerIndex operator<= (const MillerIndex &a, const CScalar &b)
MillerIndex operator<= (const CScalar &a, const MillerIndex &b)
MillerIndex operator&& (const MillerIndex &a, const CScalar &b)
MillerIndex operator&& (const CScalar &a, const MillerIndex &b)
MillerIndex operator|| (const MillerIndex &a, const CScalar &b)
MillerIndex operator|| (const CScalar &a, const MillerIndex &b)
MillerIndex operator== (const MillerIndex &a, const CScalar &b)
MillerIndex operator== (const CScalar &a, const MillerIndex &b)
MillerIndex operator!= (const MillerIndex &a, const CScalar &b)
MillerIndex operator!= (const CScalar &a, const MillerIndex &b)
MillerIndex gt (const MillerIndex &a, const CScalar &b)
MillerIndex gt (const CScalar &a, const MillerIndex &b)
MillerIndex lt (const MillerIndex &a, const CScalar &b)
MillerIndex lt (const CScalar &a, const MillerIndex &b)
MillerIndex ge (const MillerIndex &a, const CScalar &b)
MillerIndex ge (const CScalar &a, const MillerIndex &b)
MillerIndex le (const MillerIndex &a, const CScalar &b)
MillerIndex le (const CScalar &a, const MillerIndex &b)
MillerIndex logical_and (const MillerIndex &a, const CScalar &b)
MillerIndex logical_and (const CScalar &a, const MillerIndex &b)
MillerIndex logical_or (const MillerIndex &a, const CScalar &b)
MillerIndex logical_or (const CScalar &a, const MillerIndex &b)
MillerIndex logical_xor (const MillerIndex &a, const CScalar &b)
MillerIndex logical_xor (const CScalar &a, const MillerIndex &b)
MillerIndex eq (const MillerIndex &a, const CScalar &b)
MillerIndex eq (const CScalar &a, const MillerIndex &b)
MillerIndex ne (const MillerIndex &a, const CScalar &b)
MillerIndex ne (const CScalar &a, const MillerIndex &b)
Tensor operator> (const Tensor &a, const Tensor &b)
Tensor operator< (const Tensor &a, const Tensor &b)
Tensor operator>= (const Tensor &a, const Tensor &b)
Tensor operator<= (const Tensor &a, const Tensor &b)
Tensor operator&& (const Tensor &a, const Tensor &b)
Tensor operator|| (const Tensor &a, const Tensor &b)
Tensor operator== (const Tensor &a, const Tensor &b)
Tensor operator!= (const Tensor &a, const Tensor &b)
Tensor gt (const Tensor &a, const Tensor &b)
Tensor lt (const Tensor &a, const Tensor &b)
Tensor ge (const Tensor &a, const Tensor &b)
Tensor le (const Tensor &a, const Tensor &b)
Tensor logical_and (const Tensor &a, const Tensor &b)
Tensor logical_or (const Tensor &a, const Tensor &b)
Tensor logical_xor (const Tensor &a, const Tensor &b)
Tensor eq (const Tensor &a, const Tensor &b)
Tensor ne (const Tensor &a, const Tensor &b)
Tensor operator! (const Tensor &a)
Tensor logical_not (const Tensor &a)
Tensor operator> (const Tensor &a, const Scalar &b)
Tensor operator> (const Scalar &a, const Tensor &b)
Tensor operator< (const Tensor &a, const Scalar &b)
Tensor operator< (const Scalar &a, const Tensor &b)
Tensor operator>= (const Tensor &a, const Scalar &b)
Tensor operator>= (const Scalar &a, const Tensor &b)
Tensor operator<= (const Tensor &a, const Scalar &b)
Tensor operator<= (const Scalar &a, const Tensor &b)
Tensor operator&& (const Tensor &a, const Scalar &b)
Tensor operator&& (const Scalar &a, const Tensor &b)
Tensor operator|| (const Tensor &a, const Scalar &b)
Tensor operator|| (const Scalar &a, const Tensor &b)
Tensor operator== (const Tensor &a, const Scalar &b)
Tensor operator== (const Scalar &a, const Tensor &b)
Tensor operator!= (const Tensor &a, const Scalar &b)
Tensor operator!= (const Scalar &a, const Tensor &b)
Tensor gt (const Tensor &a, const Scalar &b)
Tensor gt (const Scalar &a, const Tensor &b)
Tensor lt (const Tensor &a, const Scalar &b)
Tensor lt (const Scalar &a, const Tensor &b)
Tensor ge (const Tensor &a, const Scalar &b)
Tensor ge (const Scalar &a, const Tensor &b)
Tensor le (const Tensor &a, const Scalar &b)
Tensor le (const Scalar &a, const Tensor &b)
Tensor logical_and (const Tensor &a, const Scalar &b)
Tensor logical_and (const Scalar &a, const Tensor &b)
Tensor logical_or (const Tensor &a, const Scalar &b)
Tensor logical_or (const Scalar &a, const Tensor &b)
Tensor logical_xor (const Tensor &a, const Scalar &b)
Tensor logical_xor (const Scalar &a, const Tensor &b)
Tensor eq (const Tensor &a, const Scalar &b)
Tensor eq (const Scalar &a, const Tensor &b)
Tensor ne (const Tensor &a, const Scalar &b)
Tensor ne (const Scalar &a, const Tensor &b)
Tensor operator> (const Tensor &a, const CScalar &b)
Tensor operator> (const CScalar &a, const Tensor &b)
Tensor operator< (const Tensor &a, const CScalar &b)
Tensor operator< (const CScalar &a, const Tensor &b)
Tensor operator>= (const Tensor &a, const CScalar &b)
Tensor operator>= (const CScalar &a, const Tensor &b)
Tensor operator<= (const Tensor &a, const CScalar &b)
Tensor operator<= (const CScalar &a, const Tensor &b)
Tensor operator&& (const Tensor &a, const CScalar &b)
Tensor operator&& (const CScalar &a, const Tensor &b)
Tensor operator|| (const Tensor &a, const CScalar &b)
Tensor operator|| (const CScalar &a, const Tensor &b)
Tensor operator== (const Tensor &a, const CScalar &b)
Tensor operator== (const CScalar &a, const Tensor &b)
Tensor operator!= (const Tensor &a, const CScalar &b)
Tensor operator!= (const CScalar &a, const Tensor &b)
Tensor gt (const Tensor &a, const CScalar &b)
Tensor gt (const CScalar &a, const Tensor &b)
Tensor lt (const Tensor &a, const CScalar &b)
Tensor lt (const CScalar &a, const Tensor &b)
Tensor ge (const Tensor &a, const CScalar &b)
Tensor ge (const CScalar &a, const Tensor &b)
Tensor le (const Tensor &a, const CScalar &b)
Tensor le (const CScalar &a, const Tensor &b)
Tensor logical_and (const Tensor &a, const CScalar &b)
Tensor logical_and (const CScalar &a, const Tensor &b)
Tensor logical_or (const Tensor &a, const CScalar &b)
Tensor logical_or (const CScalar &a, const Tensor &b)
Tensor logical_xor (const Tensor &a, const CScalar &b)
Tensor logical_xor (const CScalar &a, const Tensor &b)
Tensor eq (const Tensor &a, const CScalar &b)
Tensor eq (const CScalar &a, const Tensor &b)
Tensor ne (const Tensor &a, const CScalar &b)
Tensor ne (const CScalar &a, const Tensor &b)
Scalar operator> (const Scalar &a, const Scalar &b)
Scalar operator< (const Scalar &a, const Scalar &b)
Scalar operator>= (const Scalar &a, const Scalar &b)
Scalar operator<= (const Scalar &a, const Scalar &b)
Scalar operator&& (const Scalar &a, const Scalar &b)
Scalar operator|| (const Scalar &a, const Scalar &b)
Scalar operator== (const Scalar &a, const Scalar &b)
Scalar operator!= (const Scalar &a, const Scalar &b)
Scalar gt (const Scalar &a, const Scalar &b)
Scalar lt (const Scalar &a, const Scalar &b)
Scalar ge (const Scalar &a, const Scalar &b)
Scalar le (const Scalar &a, const Scalar &b)
Scalar logical_and (const Scalar &a, const Scalar &b)
Scalar logical_or (const Scalar &a, const Scalar &b)
Scalar logical_xor (const Scalar &a, const Scalar &b)
Scalar eq (const Scalar &a, const Scalar &b)
Scalar ne (const Scalar &a, const Scalar &b)
Scalar operator! (const Scalar &a)
Scalar logical_not (const Scalar &a)
Scalar operator> (const Scalar &a, const CScalar &b)
Scalar operator> (const CScalar &a, const Scalar &b)
Scalar operator< (const Scalar &a, const CScalar &b)
Scalar operator< (const CScalar &a, const Scalar &b)
Scalar operator>= (const Scalar &a, const CScalar &b)
Scalar operator>= (const CScalar &a, const Scalar &b)
Scalar operator<= (const Scalar &a, const CScalar &b)
Scalar operator<= (const CScalar &a, const Scalar &b)
Scalar operator&& (const Scalar &a, const CScalar &b)
Scalar operator&& (const CScalar &a, const Scalar &b)
Scalar operator|| (const Scalar &a, const CScalar &b)
Scalar operator|| (const CScalar &a, const Scalar &b)
Scalar operator== (const Scalar &a, const CScalar &b)
Scalar operator== (const CScalar &a, const Scalar &b)
Scalar operator!= (const Scalar &a, const CScalar &b)
Scalar operator!= (const CScalar &a, const Scalar &b)
Scalar gt (const Scalar &a, const CScalar &b)
Scalar gt (const CScalar &a, const Scalar &b)
Scalar lt (const Scalar &a, const CScalar &b)
Scalar lt (const CScalar &a, const Scalar &b)
Scalar ge (const Scalar &a, const CScalar &b)
Scalar ge (const CScalar &a, const Scalar &b)
Scalar le (const Scalar &a, const CScalar &b)
Scalar le (const CScalar &a, const Scalar &b)
Scalar logical_and (const Scalar &a, const CScalar &b)
Scalar logical_and (const CScalar &a, const Scalar &b)
Scalar logical_or (const Scalar &a, const CScalar &b)
Scalar logical_or (const CScalar &a, const Scalar &b)
Scalar logical_xor (const Scalar &a, const CScalar &b)
Scalar logical_xor (const CScalar &a, const Scalar &b)
Scalar eq (const Scalar &a, const CScalar &b)
Scalar eq (const CScalar &a, const Scalar &b)
Scalar ne (const Scalar &a, const CScalar &b)
Scalar ne (const CScalar &a, const Scalar &b)
Vec macaulay (const Vec &a)
Rot macaulay (const Rot &a)
WR2 macaulay (const WR2 &a)
R2 macaulay (const R2 &a)
SR2 macaulay (const SR2 &a)
R3 macaulay (const R3 &a)
SFR3 macaulay (const SFR3 &a)
R4 macaulay (const R4 &a)
SFFR4 macaulay (const SFFR4 &a)
WFFR4 macaulay (const WFFR4 &a)
SSR4 macaulay (const SSR4 &a)
SWR4 macaulay (const SWR4 &a)
WSR4 macaulay (const WSR4 &a)
WWR4 macaulay (const WWR4 &a)
Quaternion macaulay (const Quaternion &a)
MillerIndex macaulay (const MillerIndex &a)
Tensor macaulay (const Tensor &a)
Scalar macaulay (const Scalar &a)
Vec dynamic_max (const Vec &a, Size d=0)
Vec intmd_max (const Vec &a, Size d=0)
Rot dynamic_max (const Rot &a, Size d=0)
Rot intmd_max (const Rot &a, Size d=0)
WR2 dynamic_max (const WR2 &a, Size d=0)
WR2 intmd_max (const WR2 &a, Size d=0)
R2 dynamic_max (const R2 &a, Size d=0)
R2 intmd_max (const R2 &a, Size d=0)
SR2 dynamic_max (const SR2 &a, Size d=0)
SR2 intmd_max (const SR2 &a, Size d=0)
R3 dynamic_max (const R3 &a, Size d=0)
R3 intmd_max (const R3 &a, Size d=0)
SFR3 dynamic_max (const SFR3 &a, Size d=0)
SFR3 intmd_max (const SFR3 &a, Size d=0)
R4 dynamic_max (const R4 &a, Size d=0)
R4 intmd_max (const R4 &a, Size d=0)
SFFR4 dynamic_max (const SFFR4 &a, Size d=0)
SFFR4 intmd_max (const SFFR4 &a, Size d=0)
WFFR4 dynamic_max (const WFFR4 &a, Size d=0)
WFFR4 intmd_max (const WFFR4 &a, Size d=0)
SSR4 dynamic_max (const SSR4 &a, Size d=0)
SSR4 intmd_max (const SSR4 &a, Size d=0)
SWR4 dynamic_max (const SWR4 &a, Size d=0)
SWR4 intmd_max (const SWR4 &a, Size d=0)
WSR4 dynamic_max (const WSR4 &a, Size d=0)
WSR4 intmd_max (const WSR4 &a, Size d=0)
WWR4 dynamic_max (const WWR4 &a, Size d=0)
WWR4 intmd_max (const WWR4 &a, Size d=0)
Quaternion dynamic_max (const Quaternion &a, Size d=0)
Quaternion intmd_max (const Quaternion &a, Size d=0)
MillerIndex dynamic_max (const MillerIndex &a, Size d=0)
MillerIndex intmd_max (const MillerIndex &a, Size d=0)
Tensor dynamic_max (const Tensor &a, Size d=0)
Tensor intmd_max (const Tensor &a, Size d=0)
Scalar dynamic_max (const Scalar &a, Size d=0)
Scalar intmd_max (const Scalar &a, Size d=0)
Tensor base_max (const Tensor &a, Size d=0)
Vec dynamic_mean (const Vec &a, Size d=0)
Vec intmd_mean (const Vec &a, Size d=0)
Rot dynamic_mean (const Rot &a, Size d=0)
Rot intmd_mean (const Rot &a, Size d=0)
WR2 dynamic_mean (const WR2 &a, Size d=0)
WR2 intmd_mean (const WR2 &a, Size d=0)
R2 dynamic_mean (const R2 &a, Size d=0)
R2 intmd_mean (const R2 &a, Size d=0)
SR2 dynamic_mean (const SR2 &a, Size d=0)
SR2 intmd_mean (const SR2 &a, Size d=0)
R3 dynamic_mean (const R3 &a, Size d=0)
R3 intmd_mean (const R3 &a, Size d=0)
SFR3 dynamic_mean (const SFR3 &a, Size d=0)
SFR3 intmd_mean (const SFR3 &a, Size d=0)
R4 dynamic_mean (const R4 &a, Size d=0)
R4 intmd_mean (const R4 &a, Size d=0)
SFFR4 dynamic_mean (const SFFR4 &a, Size d=0)
SFFR4 intmd_mean (const SFFR4 &a, Size d=0)
WFFR4 dynamic_mean (const WFFR4 &a, Size d=0)
WFFR4 intmd_mean (const WFFR4 &a, Size d=0)
SSR4 dynamic_mean (const SSR4 &a, Size d=0)
SSR4 intmd_mean (const SSR4 &a, Size d=0)
SWR4 dynamic_mean (const SWR4 &a, Size d=0)
SWR4 intmd_mean (const SWR4 &a, Size d=0)
WSR4 dynamic_mean (const WSR4 &a, Size d=0)
WSR4 intmd_mean (const WSR4 &a, Size d=0)
WWR4 dynamic_mean (const WWR4 &a, Size d=0)
WWR4 intmd_mean (const WWR4 &a, Size d=0)
Quaternion dynamic_mean (const Quaternion &a, Size d=0)
Quaternion intmd_mean (const Quaternion &a, Size d=0)
MillerIndex dynamic_mean (const MillerIndex &a, Size d=0)
MillerIndex intmd_mean (const MillerIndex &a, Size d=0)
Tensor dynamic_mean (const Tensor &a, Size d=0)
Tensor intmd_mean (const Tensor &a, Size d=0)
Scalar dynamic_mean (const Scalar &a, Size d=0)
Scalar intmd_mean (const Scalar &a, Size d=0)
Tensor base_mean (const Tensor &a, Size d=0)
Vec dynamic_min (const Vec &a, Size d=0)
Vec intmd_min (const Vec &a, Size d=0)
Rot dynamic_min (const Rot &a, Size d=0)
Rot intmd_min (const Rot &a, Size d=0)
WR2 dynamic_min (const WR2 &a, Size d=0)
WR2 intmd_min (const WR2 &a, Size d=0)
R2 dynamic_min (const R2 &a, Size d=0)
R2 intmd_min (const R2 &a, Size d=0)
SR2 dynamic_min (const SR2 &a, Size d=0)
SR2 intmd_min (const SR2 &a, Size d=0)
R3 dynamic_min (const R3 &a, Size d=0)
R3 intmd_min (const R3 &a, Size d=0)
SFR3 dynamic_min (const SFR3 &a, Size d=0)
SFR3 intmd_min (const SFR3 &a, Size d=0)
R4 dynamic_min (const R4 &a, Size d=0)
R4 intmd_min (const R4 &a, Size d=0)
SFFR4 dynamic_min (const SFFR4 &a, Size d=0)
SFFR4 intmd_min (const SFFR4 &a, Size d=0)
WFFR4 dynamic_min (const WFFR4 &a, Size d=0)
WFFR4 intmd_min (const WFFR4 &a, Size d=0)
SSR4 dynamic_min (const SSR4 &a, Size d=0)
SSR4 intmd_min (const SSR4 &a, Size d=0)
SWR4 dynamic_min (const SWR4 &a, Size d=0)
SWR4 intmd_min (const SWR4 &a, Size d=0)
WSR4 dynamic_min (const WSR4 &a, Size d=0)
WSR4 intmd_min (const WSR4 &a, Size d=0)
WWR4 dynamic_min (const WWR4 &a, Size d=0)
WWR4 intmd_min (const WWR4 &a, Size d=0)
Quaternion dynamic_min (const Quaternion &a, Size d=0)
Quaternion intmd_min (const Quaternion &a, Size d=0)
MillerIndex dynamic_min (const MillerIndex &a, Size d=0)
MillerIndex intmd_min (const MillerIndex &a, Size d=0)
Tensor dynamic_min (const Tensor &a, Size d=0)
Tensor intmd_min (const Tensor &a, Size d=0)
Scalar dynamic_min (const Scalar &a, Size d=0)
Scalar intmd_min (const Scalar &a, Size d=0)
Tensor base_min (const Tensor &a, Size d=0)
Vec minimum (const Vec &a, const Vec &b)
Rot minimum (const Rot &a, const Rot &b)
WR2 minimum (const WR2 &a, const WR2 &b)
R2 minimum (const R2 &a, const R2 &b)
SR2 minimum (const SR2 &a, const SR2 &b)
R3 minimum (const R3 &a, const R3 &b)
SFR3 minimum (const SFR3 &a, const SFR3 &b)
R4 minimum (const R4 &a, const R4 &b)
SFFR4 minimum (const SFFR4 &a, const SFFR4 &b)
WFFR4 minimum (const WFFR4 &a, const WFFR4 &b)
SSR4 minimum (const SSR4 &a, const SSR4 &b)
SWR4 minimum (const SWR4 &a, const SWR4 &b)
WSR4 minimum (const WSR4 &a, const WSR4 &b)
WWR4 minimum (const WWR4 &a, const WWR4 &b)
Quaternion minimum (const Quaternion &a, const Quaternion &b)
MillerIndex minimum (const MillerIndex &a, const MillerIndex &b)
Tensor minimum (const Tensor &a, const Tensor &b)
Scalar minimum (const Scalar &a, const Scalar &b)
Tensor mm (const Tensor &a, const Tensor &b)
 Batched matrix-matrix product.
Tensor mv (const Tensor &a, const Tensor &v)
 Batched matrix-vector product.
Scalar norm (const Tensor &a, const std::optional< CScalar > &eps=std::nullopt)
 Frobenius norm of a tensor.
Scalar norm_sq (const Tensor &a)
 Squared Frobenius norm of a tensor.
Vec operator+ (const Vec &a, const Vec &b)
Rot operator+ (const Rot &a, const Rot &b)
WR2 operator+ (const WR2 &a, const WR2 &b)
R2 operator+ (const R2 &a, const R2 &b)
SR2 operator+ (const SR2 &a, const SR2 &b)
R3 operator+ (const R3 &a, const R3 &b)
SFR3 operator+ (const SFR3 &a, const SFR3 &b)
R4 operator+ (const R4 &a, const R4 &b)
SFFR4 operator+ (const SFFR4 &a, const SFFR4 &b)
WFFR4 operator+ (const WFFR4 &a, const WFFR4 &b)
SSR4 operator+ (const SSR4 &a, const SSR4 &b)
SWR4 operator+ (const SWR4 &a, const SWR4 &b)
WSR4 operator+ (const WSR4 &a, const WSR4 &b)
WWR4 operator+ (const WWR4 &a, const WWR4 &b)
Quaternion operator+ (const Quaternion &a, const Quaternion &b)
MillerIndex operator+ (const MillerIndex &a, const MillerIndex &b)
Vec operator+ (const Vec &a, const Scalar &b)
Vec operator+ (const Scalar &a, const Vec &b)
Rot operator+ (const Rot &a, const Scalar &b)
Rot operator+ (const Scalar &a, const Rot &b)
WR2 operator+ (const WR2 &a, const Scalar &b)
WR2 operator+ (const Scalar &a, const WR2 &b)
R2 operator+ (const R2 &a, const Scalar &b)
R2 operator+ (const Scalar &a, const R2 &b)
SR2 operator+ (const SR2 &a, const Scalar &b)
SR2 operator+ (const Scalar &a, const SR2 &b)
R3 operator+ (const R3 &a, const Scalar &b)
R3 operator+ (const Scalar &a, const R3 &b)
SFR3 operator+ (const SFR3 &a, const Scalar &b)
SFR3 operator+ (const Scalar &a, const SFR3 &b)
R4 operator+ (const R4 &a, const Scalar &b)
R4 operator+ (const Scalar &a, const R4 &b)
SFFR4 operator+ (const SFFR4 &a, const Scalar &b)
SFFR4 operator+ (const Scalar &a, const SFFR4 &b)
WFFR4 operator+ (const WFFR4 &a, const Scalar &b)
WFFR4 operator+ (const Scalar &a, const WFFR4 &b)
SSR4 operator+ (const SSR4 &a, const Scalar &b)
SSR4 operator+ (const Scalar &a, const SSR4 &b)
SWR4 operator+ (const SWR4 &a, const Scalar &b)
SWR4 operator+ (const Scalar &a, const SWR4 &b)
WSR4 operator+ (const WSR4 &a, const Scalar &b)
WSR4 operator+ (const Scalar &a, const WSR4 &b)
WWR4 operator+ (const WWR4 &a, const Scalar &b)
WWR4 operator+ (const Scalar &a, const WWR4 &b)
Quaternion operator+ (const Quaternion &a, const Scalar &b)
Quaternion operator+ (const Scalar &a, const Quaternion &b)
MillerIndex operator+ (const MillerIndex &a, const Scalar &b)
MillerIndex operator+ (const Scalar &a, const MillerIndex &b)
Vec operator+ (const Vec &a, const CScalar &b)
Vec operator+ (const CScalar &a, const Vec &b)
Rot operator+ (const Rot &a, const CScalar &b)
Rot operator+ (const CScalar &a, const Rot &b)
WR2 operator+ (const WR2 &a, const CScalar &b)
WR2 operator+ (const CScalar &a, const WR2 &b)
R2 operator+ (const R2 &a, const CScalar &b)
R2 operator+ (const CScalar &a, const R2 &b)
SR2 operator+ (const SR2 &a, const CScalar &b)
SR2 operator+ (const CScalar &a, const SR2 &b)
R3 operator+ (const R3 &a, const CScalar &b)
R3 operator+ (const CScalar &a, const R3 &b)
SFR3 operator+ (const SFR3 &a, const CScalar &b)
SFR3 operator+ (const CScalar &a, const SFR3 &b)
R4 operator+ (const R4 &a, const CScalar &b)
R4 operator+ (const CScalar &a, const R4 &b)
SFFR4 operator+ (const SFFR4 &a, const CScalar &b)
SFFR4 operator+ (const CScalar &a, const SFFR4 &b)
WFFR4 operator+ (const WFFR4 &a, const CScalar &b)
WFFR4 operator+ (const CScalar &a, const WFFR4 &b)
SSR4 operator+ (const SSR4 &a, const CScalar &b)
SSR4 operator+ (const CScalar &a, const SSR4 &b)
SWR4 operator+ (const SWR4 &a, const CScalar &b)
SWR4 operator+ (const CScalar &a, const SWR4 &b)
WSR4 operator+ (const WSR4 &a, const CScalar &b)
WSR4 operator+ (const CScalar &a, const WSR4 &b)
WWR4 operator+ (const WWR4 &a, const CScalar &b)
WWR4 operator+ (const CScalar &a, const WWR4 &b)
Quaternion operator+ (const Quaternion &a, const CScalar &b)
Quaternion operator+ (const CScalar &a, const Quaternion &b)
MillerIndex operator+ (const MillerIndex &a, const CScalar &b)
MillerIndex operator+ (const CScalar &a, const MillerIndex &b)
Tensor operator+ (const Tensor &a, const Tensor &b)
Tensor operator+ (const Tensor &a, const Scalar &b)
Tensor operator+ (const Scalar &a, const Tensor &b)
Tensor operator+ (const Tensor &a, const CScalar &b)
Tensor operator+ (const CScalar &a, const Tensor &b)
Scalar operator+ (const Scalar &a, const Scalar &b)
Scalar operator+ (const Scalar &a, const CScalar &b)
Scalar operator+ (const CScalar &a, const Scalar &b)
Vec operator- (const Vec &a, const Vec &b)
Rot operator- (const Rot &a, const Rot &b)
WR2 operator- (const WR2 &a, const WR2 &b)
R2 operator- (const R2 &a, const R2 &b)
SR2 operator- (const SR2 &a, const SR2 &b)
R3 operator- (const R3 &a, const R3 &b)
SFR3 operator- (const SFR3 &a, const SFR3 &b)
R4 operator- (const R4 &a, const R4 &b)
SFFR4 operator- (const SFFR4 &a, const SFFR4 &b)
WFFR4 operator- (const WFFR4 &a, const WFFR4 &b)
SSR4 operator- (const SSR4 &a, const SSR4 &b)
SWR4 operator- (const SWR4 &a, const SWR4 &b)
WSR4 operator- (const WSR4 &a, const WSR4 &b)
WWR4 operator- (const WWR4 &a, const WWR4 &b)
Quaternion operator- (const Quaternion &a, const Quaternion &b)
MillerIndex operator- (const MillerIndex &a, const MillerIndex &b)
Vec operator- (const Vec &a, const Scalar &b)
Vec operator- (const Scalar &a, const Vec &b)
Rot operator- (const Rot &a, const Scalar &b)
Rot operator- (const Scalar &a, const Rot &b)
WR2 operator- (const WR2 &a, const Scalar &b)
WR2 operator- (const Scalar &a, const WR2 &b)
R2 operator- (const R2 &a, const Scalar &b)
R2 operator- (const Scalar &a, const R2 &b)
SR2 operator- (const SR2 &a, const Scalar &b)
SR2 operator- (const Scalar &a, const SR2 &b)
R3 operator- (const R3 &a, const Scalar &b)
R3 operator- (const Scalar &a, const R3 &b)
SFR3 operator- (const SFR3 &a, const Scalar &b)
SFR3 operator- (const Scalar &a, const SFR3 &b)
R4 operator- (const R4 &a, const Scalar &b)
R4 operator- (const Scalar &a, const R4 &b)
SFFR4 operator- (const SFFR4 &a, const Scalar &b)
SFFR4 operator- (const Scalar &a, const SFFR4 &b)
WFFR4 operator- (const WFFR4 &a, const Scalar &b)
WFFR4 operator- (const Scalar &a, const WFFR4 &b)
SSR4 operator- (const SSR4 &a, const Scalar &b)
SSR4 operator- (const Scalar &a, const SSR4 &b)
SWR4 operator- (const SWR4 &a, const Scalar &b)
SWR4 operator- (const Scalar &a, const SWR4 &b)
WSR4 operator- (const WSR4 &a, const Scalar &b)
WSR4 operator- (const Scalar &a, const WSR4 &b)
WWR4 operator- (const WWR4 &a, const Scalar &b)
WWR4 operator- (const Scalar &a, const WWR4 &b)
Quaternion operator- (const Quaternion &a, const Scalar &b)
Quaternion operator- (const Scalar &a, const Quaternion &b)
MillerIndex operator- (const MillerIndex &a, const Scalar &b)
MillerIndex operator- (const Scalar &a, const MillerIndex &b)
Vec operator- (const Vec &a, const CScalar &b)
Vec operator- (const CScalar &a, const Vec &b)
Rot operator- (const Rot &a, const CScalar &b)
Rot operator- (const CScalar &a, const Rot &b)
WR2 operator- (const WR2 &a, const CScalar &b)
WR2 operator- (const CScalar &a, const WR2 &b)
R2 operator- (const R2 &a, const CScalar &b)
R2 operator- (const CScalar &a, const R2 &b)
SR2 operator- (const SR2 &a, const CScalar &b)
SR2 operator- (const CScalar &a, const SR2 &b)
R3 operator- (const R3 &a, const CScalar &b)
R3 operator- (const CScalar &a, const R3 &b)
SFR3 operator- (const SFR3 &a, const CScalar &b)
SFR3 operator- (const CScalar &a, const SFR3 &b)
R4 operator- (const R4 &a, const CScalar &b)
R4 operator- (const CScalar &a, const R4 &b)
SFFR4 operator- (const SFFR4 &a, const CScalar &b)
SFFR4 operator- (const CScalar &a, const SFFR4 &b)
WFFR4 operator- (const WFFR4 &a, const CScalar &b)
WFFR4 operator- (const CScalar &a, const WFFR4 &b)
SSR4 operator- (const SSR4 &a, const CScalar &b)
SSR4 operator- (const CScalar &a, const SSR4 &b)
SWR4 operator- (const SWR4 &a, const CScalar &b)
SWR4 operator- (const CScalar &a, const SWR4 &b)
WSR4 operator- (const WSR4 &a, const CScalar &b)
WSR4 operator- (const CScalar &a, const WSR4 &b)
WWR4 operator- (const WWR4 &a, const CScalar &b)
WWR4 operator- (const CScalar &a, const WWR4 &b)
Quaternion operator- (const Quaternion &a, const CScalar &b)
Quaternion operator- (const CScalar &a, const Quaternion &b)
MillerIndex operator- (const MillerIndex &a, const CScalar &b)
MillerIndex operator- (const CScalar &a, const MillerIndex &b)
Tensor operator- (const Tensor &a, const Tensor &b)
Tensor operator- (const Tensor &a, const Scalar &b)
Tensor operator- (const Scalar &a, const Tensor &b)
Tensor operator- (const Tensor &a, const CScalar &b)
Tensor operator- (const CScalar &a, const Tensor &b)
Scalar operator- (const Scalar &a, const Scalar &b)
Scalar operator- (const Scalar &a, const CScalar &b)
Scalar operator- (const CScalar &a, const Scalar &b)
Vec operator* (const Vec &a, const Scalar &b)
Vec operator* (const Scalar &a, const Vec &b)
Rot operator* (const Rot &a, const Scalar &b)
Rot operator* (const Scalar &a, const Rot &b)
WR2 operator* (const WR2 &a, const Scalar &b)
WR2 operator* (const Scalar &a, const WR2 &b)
R2 operator* (const R2 &a, const Scalar &b)
R2 operator* (const Scalar &a, const R2 &b)
SR2 operator* (const SR2 &a, const Scalar &b)
SR2 operator* (const Scalar &a, const SR2 &b)
R3 operator* (const R3 &a, const Scalar &b)
R3 operator* (const Scalar &a, const R3 &b)
SFR3 operator* (const SFR3 &a, const Scalar &b)
SFR3 operator* (const Scalar &a, const SFR3 &b)
R4 operator* (const R4 &a, const Scalar &b)
R4 operator* (const Scalar &a, const R4 &b)
SFFR4 operator* (const SFFR4 &a, const Scalar &b)
SFFR4 operator* (const Scalar &a, const SFFR4 &b)
WFFR4 operator* (const WFFR4 &a, const Scalar &b)
WFFR4 operator* (const Scalar &a, const WFFR4 &b)
SSR4 operator* (const SSR4 &a, const Scalar &b)
SSR4 operator* (const Scalar &a, const SSR4 &b)
SWR4 operator* (const SWR4 &a, const Scalar &b)
SWR4 operator* (const Scalar &a, const SWR4 &b)
WSR4 operator* (const WSR4 &a, const Scalar &b)
WSR4 operator* (const Scalar &a, const WSR4 &b)
WWR4 operator* (const WWR4 &a, const Scalar &b)
WWR4 operator* (const Scalar &a, const WWR4 &b)
Quaternion operator* (const Quaternion &a, const Scalar &b)
Quaternion operator* (const Scalar &a, const Quaternion &b)
MillerIndex operator* (const MillerIndex &a, const Scalar &b)
MillerIndex operator* (const Scalar &a, const MillerIndex &b)
Vec operator* (const Vec &a, const CScalar &b)
Vec operator* (const CScalar &a, const Vec &b)
Rot operator* (const Rot &a, const CScalar &b)
Rot operator* (const CScalar &a, const Rot &b)
WR2 operator* (const WR2 &a, const CScalar &b)
WR2 operator* (const CScalar &a, const WR2 &b)
R2 operator* (const R2 &a, const CScalar &b)
R2 operator* (const CScalar &a, const R2 &b)
SR2 operator* (const SR2 &a, const CScalar &b)
SR2 operator* (const CScalar &a, const SR2 &b)
R3 operator* (const R3 &a, const CScalar &b)
R3 operator* (const CScalar &a, const R3 &b)
SFR3 operator* (const SFR3 &a, const CScalar &b)
SFR3 operator* (const CScalar &a, const SFR3 &b)
R4 operator* (const R4 &a, const CScalar &b)
R4 operator* (const CScalar &a, const R4 &b)
SFFR4 operator* (const SFFR4 &a, const CScalar &b)
SFFR4 operator* (const CScalar &a, const SFFR4 &b)
WFFR4 operator* (const WFFR4 &a, const CScalar &b)
WFFR4 operator* (const CScalar &a, const WFFR4 &b)
SSR4 operator* (const SSR4 &a, const CScalar &b)
SSR4 operator* (const CScalar &a, const SSR4 &b)
SWR4 operator* (const SWR4 &a, const CScalar &b)
SWR4 operator* (const CScalar &a, const SWR4 &b)
WSR4 operator* (const WSR4 &a, const CScalar &b)
WSR4 operator* (const CScalar &a, const WSR4 &b)
WWR4 operator* (const WWR4 &a, const CScalar &b)
WWR4 operator* (const CScalar &a, const WWR4 &b)
Quaternion operator* (const Quaternion &a, const CScalar &b)
Quaternion operator* (const CScalar &a, const Quaternion &b)
MillerIndex operator* (const MillerIndex &a, const CScalar &b)
MillerIndex operator* (const CScalar &a, const MillerIndex &b)
Tensor operator* (const Tensor &a, const Tensor &b)
Tensor operator* (const Tensor &a, const Scalar &b)
Tensor operator* (const Scalar &a, const Tensor &b)
Tensor operator* (const Tensor &a, const CScalar &b)
Tensor operator* (const CScalar &a, const Tensor &b)
Scalar operator* (const Scalar &a, const Scalar &b)
Scalar operator* (const Scalar &a, const CScalar &b)
Scalar operator* (const CScalar &a, const Scalar &b)
Vec operator/ (const Vec &a, const Scalar &b)
Vec operator/ (const Scalar &a, const Vec &b)
Rot operator/ (const Rot &a, const Scalar &b)
Rot operator/ (const Scalar &a, const Rot &b)
WR2 operator/ (const WR2 &a, const Scalar &b)
WR2 operator/ (const Scalar &a, const WR2 &b)
R2 operator/ (const R2 &a, const Scalar &b)
R2 operator/ (const Scalar &a, const R2 &b)
SR2 operator/ (const SR2 &a, const Scalar &b)
SR2 operator/ (const Scalar &a, const SR2 &b)
R3 operator/ (const R3 &a, const Scalar &b)
R3 operator/ (const Scalar &a, const R3 &b)
SFR3 operator/ (const SFR3 &a, const Scalar &b)
SFR3 operator/ (const Scalar &a, const SFR3 &b)
R4 operator/ (const R4 &a, const Scalar &b)
R4 operator/ (const Scalar &a, const R4 &b)
SFFR4 operator/ (const SFFR4 &a, const Scalar &b)
SFFR4 operator/ (const Scalar &a, const SFFR4 &b)
WFFR4 operator/ (const WFFR4 &a, const Scalar &b)
WFFR4 operator/ (const Scalar &a, const WFFR4 &b)
SSR4 operator/ (const SSR4 &a, const Scalar &b)
SSR4 operator/ (const Scalar &a, const SSR4 &b)
SWR4 operator/ (const SWR4 &a, const Scalar &b)
SWR4 operator/ (const Scalar &a, const SWR4 &b)
WSR4 operator/ (const WSR4 &a, const Scalar &b)
WSR4 operator/ (const Scalar &a, const WSR4 &b)
WWR4 operator/ (const WWR4 &a, const Scalar &b)
WWR4 operator/ (const Scalar &a, const WWR4 &b)
Quaternion operator/ (const Quaternion &a, const Scalar &b)
Quaternion operator/ (const Scalar &a, const Quaternion &b)
MillerIndex operator/ (const MillerIndex &a, const Scalar &b)
MillerIndex operator/ (const Scalar &a, const MillerIndex &b)
Vec operator/ (const Vec &a, const CScalar &b)
Vec operator/ (const CScalar &a, const Vec &b)
Rot operator/ (const Rot &a, const CScalar &b)
Rot operator/ (const CScalar &a, const Rot &b)
WR2 operator/ (const WR2 &a, const CScalar &b)
WR2 operator/ (const CScalar &a, const WR2 &b)
R2 operator/ (const R2 &a, const CScalar &b)
R2 operator/ (const CScalar &a, const R2 &b)
SR2 operator/ (const SR2 &a, const CScalar &b)
SR2 operator/ (const CScalar &a, const SR2 &b)
R3 operator/ (const R3 &a, const CScalar &b)
R3 operator/ (const CScalar &a, const R3 &b)
SFR3 operator/ (const SFR3 &a, const CScalar &b)
SFR3 operator/ (const CScalar &a, const SFR3 &b)
R4 operator/ (const R4 &a, const CScalar &b)
R4 operator/ (const CScalar &a, const R4 &b)
SFFR4 operator/ (const SFFR4 &a, const CScalar &b)
SFFR4 operator/ (const CScalar &a, const SFFR4 &b)
WFFR4 operator/ (const WFFR4 &a, const CScalar &b)
WFFR4 operator/ (const CScalar &a, const WFFR4 &b)
SSR4 operator/ (const SSR4 &a, const CScalar &b)
SSR4 operator/ (const CScalar &a, const SSR4 &b)
SWR4 operator/ (const SWR4 &a, const CScalar &b)
SWR4 operator/ (const CScalar &a, const SWR4 &b)
WSR4 operator/ (const WSR4 &a, const CScalar &b)
WSR4 operator/ (const CScalar &a, const WSR4 &b)
WWR4 operator/ (const WWR4 &a, const CScalar &b)
WWR4 operator/ (const CScalar &a, const WWR4 &b)
Quaternion operator/ (const Quaternion &a, const CScalar &b)
Quaternion operator/ (const CScalar &a, const Quaternion &b)
MillerIndex operator/ (const MillerIndex &a, const CScalar &b)
MillerIndex operator/ (const CScalar &a, const MillerIndex &b)
Tensor operator/ (const Tensor &a, const Tensor &b)
Tensor operator/ (const Tensor &a, const Scalar &b)
Tensor operator/ (const Scalar &a, const Tensor &b)
Tensor operator/ (const Tensor &a, const CScalar &b)
Tensor operator/ (const CScalar &a, const Tensor &b)
Scalar operator/ (const Scalar &a, const Scalar &b)
Scalar operator/ (const Scalar &a, const CScalar &b)
Scalar operator/ (const CScalar &a, const Scalar &b)
Vecoperator+= (Vec &a, const CScalar &b)
Rotoperator+= (Rot &a, const CScalar &b)
WR2operator+= (WR2 &a, const CScalar &b)
R2operator+= (R2 &a, const CScalar &b)
SR2operator+= (SR2 &a, const CScalar &b)
R3operator+= (R3 &a, const CScalar &b)
SFR3operator+= (SFR3 &a, const CScalar &b)
R4operator+= (R4 &a, const CScalar &b)
SFFR4operator+= (SFFR4 &a, const CScalar &b)
WFFR4operator+= (WFFR4 &a, const CScalar &b)
SSR4operator+= (SSR4 &a, const CScalar &b)
SWR4operator+= (SWR4 &a, const CScalar &b)
WSR4operator+= (WSR4 &a, const CScalar &b)
WWR4operator+= (WWR4 &a, const CScalar &b)
Quaternionoperator+= (Quaternion &a, const CScalar &b)
MillerIndexoperator+= (MillerIndex &a, const CScalar &b)
Tensoroperator+= (Tensor &a, const CScalar &b)
Scalaroperator+= (Scalar &a, const CScalar &b)
Vecoperator-= (Vec &a, const CScalar &b)
Rotoperator-= (Rot &a, const CScalar &b)
WR2operator-= (WR2 &a, const CScalar &b)
R2operator-= (R2 &a, const CScalar &b)
SR2operator-= (SR2 &a, const CScalar &b)
R3operator-= (R3 &a, const CScalar &b)
SFR3operator-= (SFR3 &a, const CScalar &b)
R4operator-= (R4 &a, const CScalar &b)
SFFR4operator-= (SFFR4 &a, const CScalar &b)
WFFR4operator-= (WFFR4 &a, const CScalar &b)
SSR4operator-= (SSR4 &a, const CScalar &b)
SWR4operator-= (SWR4 &a, const CScalar &b)
WSR4operator-= (WSR4 &a, const CScalar &b)
WWR4operator-= (WWR4 &a, const CScalar &b)
Quaternionoperator-= (Quaternion &a, const CScalar &b)
MillerIndexoperator-= (MillerIndex &a, const CScalar &b)
Tensoroperator-= (Tensor &a, const CScalar &b)
Scalaroperator-= (Scalar &a, const CScalar &b)
Vecoperator*= (Vec &a, const CScalar &b)
Rotoperator*= (Rot &a, const CScalar &b)
WR2operator*= (WR2 &a, const CScalar &b)
R2operator*= (R2 &a, const CScalar &b)
SR2operator*= (SR2 &a, const CScalar &b)
R3operator*= (R3 &a, const CScalar &b)
SFR3operator*= (SFR3 &a, const CScalar &b)
R4operator*= (R4 &a, const CScalar &b)
SFFR4operator*= (SFFR4 &a, const CScalar &b)
WFFR4operator*= (WFFR4 &a, const CScalar &b)
SSR4operator*= (SSR4 &a, const CScalar &b)
SWR4operator*= (SWR4 &a, const CScalar &b)
WSR4operator*= (WSR4 &a, const CScalar &b)
WWR4operator*= (WWR4 &a, const CScalar &b)
Quaternionoperator*= (Quaternion &a, const CScalar &b)
MillerIndexoperator*= (MillerIndex &a, const CScalar &b)
Tensoroperator*= (Tensor &a, const CScalar &b)
Scalaroperator*= (Scalar &a, const CScalar &b)
Vecoperator/= (Vec &a, const CScalar &b)
Rotoperator/= (Rot &a, const CScalar &b)
WR2operator/= (WR2 &a, const CScalar &b)
R2operator/= (R2 &a, const CScalar &b)
SR2operator/= (SR2 &a, const CScalar &b)
R3operator/= (R3 &a, const CScalar &b)
SFR3operator/= (SFR3 &a, const CScalar &b)
R4operator/= (R4 &a, const CScalar &b)
SFFR4operator/= (SFFR4 &a, const CScalar &b)
WFFR4operator/= (WFFR4 &a, const CScalar &b)
SSR4operator/= (SSR4 &a, const CScalar &b)
SWR4operator/= (SWR4 &a, const CScalar &b)
WSR4operator/= (WSR4 &a, const CScalar &b)
WWR4operator/= (WWR4 &a, const CScalar &b)
Quaternionoperator/= (Quaternion &a, const CScalar &b)
MillerIndexoperator/= (MillerIndex &a, const CScalar &b)
Tensoroperator/= (Tensor &a, const CScalar &b)
Scalaroperator/= (Scalar &a, const CScalar &b)
Vec pow (const Vec &a, const CScalar &n)
Vec pow (const Vec &a, const Scalar &n)
Rot pow (const Rot &a, const CScalar &n)
Rot pow (const Rot &a, const Scalar &n)
WR2 pow (const WR2 &a, const CScalar &n)
WR2 pow (const WR2 &a, const Scalar &n)
R2 pow (const R2 &a, const CScalar &n)
R2 pow (const R2 &a, const Scalar &n)
SR2 pow (const SR2 &a, const CScalar &n)
SR2 pow (const SR2 &a, const Scalar &n)
R3 pow (const R3 &a, const CScalar &n)
R3 pow (const R3 &a, const Scalar &n)
SFR3 pow (const SFR3 &a, const CScalar &n)
SFR3 pow (const SFR3 &a, const Scalar &n)
R4 pow (const R4 &a, const CScalar &n)
R4 pow (const R4 &a, const Scalar &n)
SFFR4 pow (const SFFR4 &a, const CScalar &n)
SFFR4 pow (const SFFR4 &a, const Scalar &n)
WFFR4 pow (const WFFR4 &a, const CScalar &n)
WFFR4 pow (const WFFR4 &a, const Scalar &n)
SSR4 pow (const SSR4 &a, const CScalar &n)
SSR4 pow (const SSR4 &a, const Scalar &n)
SWR4 pow (const SWR4 &a, const CScalar &n)
SWR4 pow (const SWR4 &a, const Scalar &n)
WSR4 pow (const WSR4 &a, const CScalar &n)
WSR4 pow (const WSR4 &a, const Scalar &n)
WWR4 pow (const WWR4 &a, const CScalar &n)
WWR4 pow (const WWR4 &a, const Scalar &n)
Quaternion pow (const Quaternion &a, const CScalar &n)
Quaternion pow (const Quaternion &a, const Scalar &n)
MillerIndex pow (const MillerIndex &a, const CScalar &n)
MillerIndex pow (const MillerIndex &a, const Scalar &n)
Tensor pow (const Tensor &a, const CScalar &n)
Tensor pow (const Tensor &a, const Scalar &n)
Scalar pow (const Scalar &a, const CScalar &n)
Scalar pow (const Scalar &a, const Scalar &n)
Scalar pow (const CScalar &a, const Scalar &n)
Tensor pow (const Tensor &a, const Tensor &n)
 Element-wise pow.
Tensor pow (const CScalar &a, const Tensor &n)
 Element-wise pow.
Vec sign (const Vec &a)
Rot sign (const Rot &a)
WR2 sign (const WR2 &a)
R2 sign (const R2 &a)
SR2 sign (const SR2 &a)
R3 sign (const R3 &a)
SFR3 sign (const SFR3 &a)
R4 sign (const R4 &a)
SFFR4 sign (const SFFR4 &a)
WFFR4 sign (const WFFR4 &a)
SSR4 sign (const SSR4 &a)
SWR4 sign (const SWR4 &a)
WSR4 sign (const WSR4 &a)
WWR4 sign (const WWR4 &a)
Quaternion sign (const Quaternion &a)
MillerIndex sign (const MillerIndex &a)
Tensor sign (const Tensor &a)
Scalar sign (const Scalar &a)
Vec sin (const Vec &a)
Rot sin (const Rot &a)
WR2 sin (const WR2 &a)
R2 sin (const R2 &a)
SR2 sin (const SR2 &a)
R3 sin (const R3 &a)
SFR3 sin (const SFR3 &a)
R4 sin (const R4 &a)
SFFR4 sin (const SFFR4 &a)
WFFR4 sin (const WFFR4 &a)
SSR4 sin (const SSR4 &a)
SWR4 sin (const SWR4 &a)
WSR4 sin (const WSR4 &a)
WWR4 sin (const WWR4 &a)
Quaternion sin (const Quaternion &a)
MillerIndex sin (const MillerIndex &a)
Tensor sin (const Tensor &a)
Scalar sin (const Scalar &a)
Vec sinh (const Vec &a)
Rot sinh (const Rot &a)
WR2 sinh (const WR2 &a)
R2 sinh (const R2 &a)
SR2 sinh (const SR2 &a)
R3 sinh (const R3 &a)
SFR3 sinh (const SFR3 &a)
R4 sinh (const R4 &a)
SFFR4 sinh (const SFFR4 &a)
WFFR4 sinh (const WFFR4 &a)
SSR4 sinh (const SSR4 &a)
SWR4 sinh (const SWR4 &a)
WSR4 sinh (const WSR4 &a)
WWR4 sinh (const WWR4 &a)
Quaternion sinh (const Quaternion &a)
MillerIndex sinh (const MillerIndex &a)
Tensor sinh (const Tensor &a)
Scalar sinh (const Scalar &a)
Vec sqrt (const Vec &a)
Rot sqrt (const Rot &a)
WR2 sqrt (const WR2 &a)
R2 sqrt (const R2 &a)
SR2 sqrt (const SR2 &a)
R3 sqrt (const R3 &a)
SFR3 sqrt (const SFR3 &a)
R4 sqrt (const R4 &a)
SFFR4 sqrt (const SFFR4 &a)
WFFR4 sqrt (const WFFR4 &a)
SSR4 sqrt (const SSR4 &a)
SWR4 sqrt (const SWR4 &a)
WSR4 sqrt (const WSR4 &a)
WWR4 sqrt (const WWR4 &a)
Quaternion sqrt (const Quaternion &a)
MillerIndex sqrt (const MillerIndex &a)
Tensor sqrt (const Tensor &a)
Scalar sqrt (const Scalar &a)
Vec dynamic_stack (const std::vector< Vec > &tensors, Size d=0)
Vec dynamic_stack (const std::initializer_list< Vec > &tensors, Size d=0)
Vec intmd_stack (const std::vector< Vec > &tensors, Size d=0)
Vec intmd_stack (const std::initializer_list< Vec > &tensors, Size d=0)
Rot dynamic_stack (const std::vector< Rot > &tensors, Size d=0)
Rot dynamic_stack (const std::initializer_list< Rot > &tensors, Size d=0)
Rot intmd_stack (const std::vector< Rot > &tensors, Size d=0)
Rot intmd_stack (const std::initializer_list< Rot > &tensors, Size d=0)
WR2 dynamic_stack (const std::vector< WR2 > &tensors, Size d=0)
WR2 dynamic_stack (const std::initializer_list< WR2 > &tensors, Size d=0)
WR2 intmd_stack (const std::vector< WR2 > &tensors, Size d=0)
WR2 intmd_stack (const std::initializer_list< WR2 > &tensors, Size d=0)
R2 dynamic_stack (const std::vector< R2 > &tensors, Size d=0)
R2 dynamic_stack (const std::initializer_list< R2 > &tensors, Size d=0)
R2 intmd_stack (const std::vector< R2 > &tensors, Size d=0)
R2 intmd_stack (const std::initializer_list< R2 > &tensors, Size d=0)
SR2 dynamic_stack (const std::vector< SR2 > &tensors, Size d=0)
SR2 dynamic_stack (const std::initializer_list< SR2 > &tensors, Size d=0)
SR2 intmd_stack (const std::vector< SR2 > &tensors, Size d=0)
SR2 intmd_stack (const std::initializer_list< SR2 > &tensors, Size d=0)
R3 dynamic_stack (const std::vector< R3 > &tensors, Size d=0)
R3 dynamic_stack (const std::initializer_list< R3 > &tensors, Size d=0)
R3 intmd_stack (const std::vector< R3 > &tensors, Size d=0)
R3 intmd_stack (const std::initializer_list< R3 > &tensors, Size d=0)
SFR3 dynamic_stack (const std::vector< SFR3 > &tensors, Size d=0)
SFR3 dynamic_stack (const std::initializer_list< SFR3 > &tensors, Size d=0)
SFR3 intmd_stack (const std::vector< SFR3 > &tensors, Size d=0)
SFR3 intmd_stack (const std::initializer_list< SFR3 > &tensors, Size d=0)
R4 dynamic_stack (const std::vector< R4 > &tensors, Size d=0)
R4 dynamic_stack (const std::initializer_list< R4 > &tensors, Size d=0)
R4 intmd_stack (const std::vector< R4 > &tensors, Size d=0)
R4 intmd_stack (const std::initializer_list< R4 > &tensors, Size d=0)
SFFR4 dynamic_stack (const std::vector< SFFR4 > &tensors, Size d=0)
SFFR4 dynamic_stack (const std::initializer_list< SFFR4 > &tensors, Size d=0)
SFFR4 intmd_stack (const std::vector< SFFR4 > &tensors, Size d=0)
SFFR4 intmd_stack (const std::initializer_list< SFFR4 > &tensors, Size d=0)
WFFR4 dynamic_stack (const std::vector< WFFR4 > &tensors, Size d=0)
WFFR4 dynamic_stack (const std::initializer_list< WFFR4 > &tensors, Size d=0)
WFFR4 intmd_stack (const std::vector< WFFR4 > &tensors, Size d=0)
WFFR4 intmd_stack (const std::initializer_list< WFFR4 > &tensors, Size d=0)
SSR4 dynamic_stack (const std::vector< SSR4 > &tensors, Size d=0)
SSR4 dynamic_stack (const std::initializer_list< SSR4 > &tensors, Size d=0)
SSR4 intmd_stack (const std::vector< SSR4 > &tensors, Size d=0)
SSR4 intmd_stack (const std::initializer_list< SSR4 > &tensors, Size d=0)
SWR4 dynamic_stack (const std::vector< SWR4 > &tensors, Size d=0)
SWR4 dynamic_stack (const std::initializer_list< SWR4 > &tensors, Size d=0)
SWR4 intmd_stack (const std::vector< SWR4 > &tensors, Size d=0)
SWR4 intmd_stack (const std::initializer_list< SWR4 > &tensors, Size d=0)
WSR4 dynamic_stack (const std::vector< WSR4 > &tensors, Size d=0)
WSR4 dynamic_stack (const std::initializer_list< WSR4 > &tensors, Size d=0)
WSR4 intmd_stack (const std::vector< WSR4 > &tensors, Size d=0)
WSR4 intmd_stack (const std::initializer_list< WSR4 > &tensors, Size d=0)
WWR4 dynamic_stack (const std::vector< WWR4 > &tensors, Size d=0)
WWR4 dynamic_stack (const std::initializer_list< WWR4 > &tensors, Size d=0)
WWR4 intmd_stack (const std::vector< WWR4 > &tensors, Size d=0)
WWR4 intmd_stack (const std::initializer_list< WWR4 > &tensors, Size d=0)
Quaternion dynamic_stack (const std::vector< Quaternion > &tensors, Size d=0)
Quaternion dynamic_stack (const std::initializer_list< Quaternion > &tensors, Size d=0)
Quaternion intmd_stack (const std::vector< Quaternion > &tensors, Size d=0)
Quaternion intmd_stack (const std::initializer_list< Quaternion > &tensors, Size d=0)
MillerIndex dynamic_stack (const std::vector< MillerIndex > &tensors, Size d=0)
MillerIndex dynamic_stack (const std::initializer_list< MillerIndex > &tensors, Size d=0)
MillerIndex intmd_stack (const std::vector< MillerIndex > &tensors, Size d=0)
MillerIndex intmd_stack (const std::initializer_list< MillerIndex > &tensors, Size d=0)
Tensor dynamic_stack (const std::vector< Tensor > &tensors, Size d=0)
Tensor dynamic_stack (const std::initializer_list< Tensor > &tensors, Size d=0)
Tensor intmd_stack (const std::vector< Tensor > &tensors, Size d=0)
Tensor intmd_stack (const std::initializer_list< Tensor > &tensors, Size d=0)
Scalar dynamic_stack (const std::vector< Scalar > &tensors, Size d=0)
Scalar dynamic_stack (const std::initializer_list< Scalar > &tensors, Size d=0)
Scalar intmd_stack (const std::vector< Scalar > &tensors, Size d=0)
Scalar intmd_stack (const std::initializer_list< Scalar > &tensors, Size d=0)
neml2::Tensor base_stack (const std::vector< Tensor > &tensors, Size d=0)
Vec dynamic_sum (const Vec &a, ArrayRef< Size > d=0, bool keepdim=false)
Vec intmd_sum (const Vec &a, ArrayRef< Size > d=0, bool keepdim=false)
Rot dynamic_sum (const Rot &a, ArrayRef< Size > d=0, bool keepdim=false)
Rot intmd_sum (const Rot &a, ArrayRef< Size > d=0, bool keepdim=false)
WR2 dynamic_sum (const WR2 &a, ArrayRef< Size > d=0, bool keepdim=false)
WR2 intmd_sum (const WR2 &a, ArrayRef< Size > d=0, bool keepdim=false)
R2 dynamic_sum (const R2 &a, ArrayRef< Size > d=0, bool keepdim=false)
R2 intmd_sum (const R2 &a, ArrayRef< Size > d=0, bool keepdim=false)
SR2 dynamic_sum (const SR2 &a, ArrayRef< Size > d=0, bool keepdim=false)
SR2 intmd_sum (const SR2 &a, ArrayRef< Size > d=0, bool keepdim=false)
R3 dynamic_sum (const R3 &a, ArrayRef< Size > d=0, bool keepdim=false)
R3 intmd_sum (const R3 &a, ArrayRef< Size > d=0, bool keepdim=false)
SFR3 dynamic_sum (const SFR3 &a, ArrayRef< Size > d=0, bool keepdim=false)
SFR3 intmd_sum (const SFR3 &a, ArrayRef< Size > d=0, bool keepdim=false)
R4 dynamic_sum (const R4 &a, ArrayRef< Size > d=0, bool keepdim=false)
R4 intmd_sum (const R4 &a, ArrayRef< Size > d=0, bool keepdim=false)
SFFR4 dynamic_sum (const SFFR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
SFFR4 intmd_sum (const SFFR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
WFFR4 dynamic_sum (const WFFR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
WFFR4 intmd_sum (const WFFR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
SSR4 dynamic_sum (const SSR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
SSR4 intmd_sum (const SSR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
SWR4 dynamic_sum (const SWR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
SWR4 intmd_sum (const SWR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
WSR4 dynamic_sum (const WSR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
WSR4 intmd_sum (const WSR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
WWR4 dynamic_sum (const WWR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
WWR4 intmd_sum (const WWR4 &a, ArrayRef< Size > d=0, bool keepdim=false)
Quaternion dynamic_sum (const Quaternion &a, ArrayRef< Size > d=0, bool keepdim=false)
Quaternion intmd_sum (const Quaternion &a, ArrayRef< Size > d=0, bool keepdim=false)
MillerIndex dynamic_sum (const MillerIndex &a, ArrayRef< Size > d=0, bool keepdim=false)
MillerIndex intmd_sum (const MillerIndex &a, ArrayRef< Size > d=0, bool keepdim=false)
Tensor dynamic_sum (const Tensor &a, ArrayRef< Size > d=0, bool keepdim=false)
Tensor intmd_sum (const Tensor &a, ArrayRef< Size > d=0, bool keepdim=false)
Scalar dynamic_sum (const Scalar &a, ArrayRef< Size > d=0, bool keepdim=false)
Scalar intmd_sum (const Scalar &a, ArrayRef< Size > d=0, bool keepdim=false)
Tensor base_sum (const Tensor &a, ArrayRef< Size > d=0, bool keepdim=false)
Vec dynamic_sum_to_size (const Vec &a, const TraceableTensorShape &shape)
Vec intmd_sum_to_size (const Vec &a, TensorShapeRef shape)
Rot dynamic_sum_to_size (const Rot &a, const TraceableTensorShape &shape)
Rot intmd_sum_to_size (const Rot &a, TensorShapeRef shape)
WR2 dynamic_sum_to_size (const WR2 &a, const TraceableTensorShape &shape)
WR2 intmd_sum_to_size (const WR2 &a, TensorShapeRef shape)
R2 dynamic_sum_to_size (const R2 &a, const TraceableTensorShape &shape)
R2 intmd_sum_to_size (const R2 &a, TensorShapeRef shape)
SR2 dynamic_sum_to_size (const SR2 &a, const TraceableTensorShape &shape)
SR2 intmd_sum_to_size (const SR2 &a, TensorShapeRef shape)
R3 dynamic_sum_to_size (const R3 &a, const TraceableTensorShape &shape)
R3 intmd_sum_to_size (const R3 &a, TensorShapeRef shape)
SFR3 dynamic_sum_to_size (const SFR3 &a, const TraceableTensorShape &shape)
SFR3 intmd_sum_to_size (const SFR3 &a, TensorShapeRef shape)
R4 dynamic_sum_to_size (const R4 &a, const TraceableTensorShape &shape)
R4 intmd_sum_to_size (const R4 &a, TensorShapeRef shape)
SFFR4 dynamic_sum_to_size (const SFFR4 &a, const TraceableTensorShape &shape)
SFFR4 intmd_sum_to_size (const SFFR4 &a, TensorShapeRef shape)
WFFR4 dynamic_sum_to_size (const WFFR4 &a, const TraceableTensorShape &shape)
WFFR4 intmd_sum_to_size (const WFFR4 &a, TensorShapeRef shape)
SSR4 dynamic_sum_to_size (const SSR4 &a, const TraceableTensorShape &shape)
SSR4 intmd_sum_to_size (const SSR4 &a, TensorShapeRef shape)
SWR4 dynamic_sum_to_size (const SWR4 &a, const TraceableTensorShape &shape)
SWR4 intmd_sum_to_size (const SWR4 &a, TensorShapeRef shape)
WSR4 dynamic_sum_to_size (const WSR4 &a, const TraceableTensorShape &shape)
WSR4 intmd_sum_to_size (const WSR4 &a, TensorShapeRef shape)
WWR4 dynamic_sum_to_size (const WWR4 &a, const TraceableTensorShape &shape)
WWR4 intmd_sum_to_size (const WWR4 &a, TensorShapeRef shape)
Quaternion dynamic_sum_to_size (const Quaternion &a, const TraceableTensorShape &shape)
Quaternion intmd_sum_to_size (const Quaternion &a, TensorShapeRef shape)
MillerIndex dynamic_sum_to_size (const MillerIndex &a, const TraceableTensorShape &shape)
MillerIndex intmd_sum_to_size (const MillerIndex &a, TensorShapeRef shape)
Tensor dynamic_sum_to_size (const Tensor &a, const TraceableTensorShape &shape)
Tensor intmd_sum_to_size (const Tensor &a, TensorShapeRef shape)
Scalar dynamic_sum_to_size (const Scalar &a, const TraceableTensorShape &shape)
Scalar intmd_sum_to_size (const Scalar &a, TensorShapeRef shape)
Tensor base_sum_to_size (const Tensor &a, TensorShapeRef shape)
constexpr double mandel_factor (Size i)
Tensor full_to_mandel (const Tensor &full, Size dim=0)
 Convert a Tensor from full notation to Mandel notation.
Tensor mandel_to_full (const Tensor &mandel, Size dim=0)
 Convert a Tensor from Mandel notation to full notation.
Tensor full_to_skew (const Tensor &full, Size dim=0)
 Convert a Tensor from full notation to skew vector notation.
Tensor skew_to_full (const Tensor &skew, Size dim=0)
 Convert a Tensor from skew vector notation to full notation.
Vec tan (const Vec &a)
Rot tan (const Rot &a)
WR2 tan (const WR2 &a)
R2 tan (const R2 &a)
SR2 tan (const SR2 &a)
R3 tan (const R3 &a)
SFR3 tan (const SFR3 &a)
R4 tan (const R4 &a)
SFFR4 tan (const SFFR4 &a)
WFFR4 tan (const WFFR4 &a)
SSR4 tan (const SSR4 &a)
SWR4 tan (const SWR4 &a)
WSR4 tan (const WSR4 &a)
WWR4 tan (const WWR4 &a)
Quaternion tan (const Quaternion &a)
MillerIndex tan (const MillerIndex &a)
Tensor tan (const Tensor &a)
Scalar tan (const Scalar &a)
Vec tanh (const Vec &a)
Rot tanh (const Rot &a)
WR2 tanh (const WR2 &a)
R2 tanh (const R2 &a)
SR2 tanh (const SR2 &a)
R3 tanh (const R3 &a)
SFR3 tanh (const SFR3 &a)
R4 tanh (const R4 &a)
SFFR4 tanh (const SFFR4 &a)
WFFR4 tanh (const WFFR4 &a)
SSR4 tanh (const SSR4 &a)
SWR4 tanh (const SWR4 &a)
WSR4 tanh (const WSR4 &a)
WWR4 tanh (const WWR4 &a)
Quaternion tanh (const Quaternion &a)
MillerIndex tanh (const MillerIndex &a)
Tensor tanh (const Tensor &a)
Scalar tanh (const Scalar &a)
Scalar vdot (const Tensor &u, const Tensor &v)
 Vector-vector dot product.
Vec where (const Tensor &c, const Vec &a, const Vec &b)
Vec where (const Scalar &c, const Vec &a, const Vec &b)
Rot where (const Tensor &c, const Rot &a, const Rot &b)
Rot where (const Scalar &c, const Rot &a, const Rot &b)
WR2 where (const Tensor &c, const WR2 &a, const WR2 &b)
WR2 where (const Scalar &c, const WR2 &a, const WR2 &b)
R2 where (const Tensor &c, const R2 &a, const R2 &b)
R2 where (const Scalar &c, const R2 &a, const R2 &b)
SR2 where (const Tensor &c, const SR2 &a, const SR2 &b)
SR2 where (const Scalar &c, const SR2 &a, const SR2 &b)
R3 where (const Tensor &c, const R3 &a, const R3 &b)
R3 where (const Scalar &c, const R3 &a, const R3 &b)
SFR3 where (const Tensor &c, const SFR3 &a, const SFR3 &b)
SFR3 where (const Scalar &c, const SFR3 &a, const SFR3 &b)
R4 where (const Tensor &c, const R4 &a, const R4 &b)
R4 where (const Scalar &c, const R4 &a, const R4 &b)
SFFR4 where (const Tensor &c, const SFFR4 &a, const SFFR4 &b)
SFFR4 where (const Scalar &c, const SFFR4 &a, const SFFR4 &b)
WFFR4 where (const Tensor &c, const WFFR4 &a, const WFFR4 &b)
WFFR4 where (const Scalar &c, const WFFR4 &a, const WFFR4 &b)
SSR4 where (const Tensor &c, const SSR4 &a, const SSR4 &b)
SSR4 where (const Scalar &c, const SSR4 &a, const SSR4 &b)
SWR4 where (const Tensor &c, const SWR4 &a, const SWR4 &b)
SWR4 where (const Scalar &c, const SWR4 &a, const SWR4 &b)
WSR4 where (const Tensor &c, const WSR4 &a, const WSR4 &b)
WSR4 where (const Scalar &c, const WSR4 &a, const WSR4 &b)
WWR4 where (const Tensor &c, const WWR4 &a, const WWR4 &b)
WWR4 where (const Scalar &c, const WWR4 &a, const WWR4 &b)
Quaternion where (const Tensor &c, const Quaternion &a, const Quaternion &b)
Quaternion where (const Scalar &c, const Quaternion &a, const Quaternion &b)
MillerIndex where (const Tensor &c, const MillerIndex &a, const MillerIndex &b)
MillerIndex where (const Scalar &c, const MillerIndex &a, const MillerIndex &b)
Tensor where (const Tensor &c, const Tensor &a, const Tensor &b)
Tensor where (const Scalar &c, const Tensor &a, const Tensor &b)
Scalar where (const Tensor &c, const Scalar &a, const Scalar &b)
Scalar where (const Scalar &c, const Scalar &a, const Scalar &b)
void neml_assert_tracing ()
 Assert that we are currently tracing.
void neml_assert_not_tracing ()
 Assert that we are currently NOT tracing.
void neml_assert_tracing_dbg ()
 Assert that we are currently tracing (only effective in debug mode).
void neml_assert_not_tracing_dbg ()
 Assert that we are currently NOT tracing (only effective in debug mode).
template<class Tuple, std::size_t... I>
auto make_tensors (Tuple &&t, std::index_sequence< I... >, const TensorOptions &options)
R2 operator* (const R2 &, const R2 &)
 matrix-matrix product
Vec operator* (const R2 &, const Vec &)
 matrix-vector product
Rot operator* (const Rot &r1, const Rot &r2)
 Composition of rotations r3 = r1 * r2 (r2 first, then r1).
Vec convert_euler_angles_from_kocks (const Vec &angles, const std::string &to_convention)
 Convert between Euler angle types.
SSR4 operator* (const SSR4 &a, const SSR4 &b)
SR2 operator* (const SSR4 &a, const SR2 &b)
std::ostream & operator<< (std::ostream &os, const TensorType &t)
std::ostream & operator<< (std::ostream &os, const TraceableSize &s)
 Streaming operator.
R2 transform_from_quaternion (const Quaternion &q)
 Construct from quaternions, useful for comparison to old NEML.
R2 identity_transform (const TensorOptions &options=default_tensor_options())
 The identity transformation, i.e.e the Rank2 identity tensor.
R2 proper_rotation_transform (const Rot &rot)
 A proper rotation, here provided by a Rot object.
R2 improper_rotation_transform (const Rot &rot)
 An improper rotation (rotation + reflection), here provided by a rot object giving the rotation and reflection axis.
R2 reflection_transform (const Vec &v)
 A reflection, defined by the reflection plane.
R2 inversion_transform (const TensorOptions &options=default_tensor_options())
 An inversion center.
SparseTensorList operator- (const SparseTensorList &)
SparseTensorList operator+ (const SparseTensorList &, const SparseTensorList &)
 Binary addition.
SparseTensorList operator* (const Scalar &, const SparseTensorList &)
 Multiplication with scalar.
SparseTensorList operator* (const SparseTensorList &, const Scalar &)
Scalar inner (const SparseTensorList &, const SparseTensorList &)
 Inner product.
Scalar norm_sq (const SparseTensorList &)
 Norm-squared.
Scalar norm (const SparseTensorList &)
 Norm.
RAII style default tensor options

The factory methods like at::arange, at::ones, at::zeros, at::rand etc. accept a common argument to configure the properties of the tensor being created. We predefine a default tensor configuration in NEML2. This default configuration is consistently used throughout NEML2.

See https://pytorch.org/cppdocs/notes/tensor_creation.html#configuring-properties-of-the-tensor for more details.

void set_default_dtype (Dtype dtype)
Dtype get_default_dtype ()
 Get default dtype.
TensorOptions default_tensor_options ()
 Default floating point tensor options.
void set_default_integer_dtype (Dtype dtype)
 Set default integer dtype.
Dtype get_default_integer_dtype ()
 Get default integer dtype.
TensorOptions default_integer_tensor_options ()
 Default integral tensor options.
template<class... T>
void neml_assert_broadcastable (const T &...)
template<class... T>
void neml_assert_dynamic_broadcastable (const T &...)
template<class... T>
void neml_assert_intmd_broadcastable (const T &...)
template<class... T>
void neml_assert_batch_broadcastable (const T &...)
template<class... T>
void neml_assert_base_broadcastable (const T &...)
template<class... T>
void neml_assert_static_broadcastable (const T &...)
Scalar det (const Tensor &)
Scalar det (const R2 &)
Scalar det (const SR2 &)
Scalar det (const WR2 &)
Tensor dev (const Tensor &)
R2 dev (const R2 &)
SR2 dev (const SR2 &)
WR2 dev (const WR2 &)
R2 inv (const R2 &)
SR2 inv (const SR2 &)
R4 inv (const R4 &)
SSR4 inv (const SSR4 &)
Vec dynamic_linspace (const Vec &start, const Vec &end, Size nstep, Size dim=0)
Vec intmd_linspace (const Vec &start, const Vec &end, Size nstep, Size dim=0)
Rot dynamic_linspace (const Rot &start, const Rot &end, Size nstep, Size dim=0)
Rot intmd_linspace (const Rot &start, const Rot &end, Size nstep, Size dim=0)
WR2 dynamic_linspace (const WR2 &start, const WR2 &end, Size nstep, Size dim=0)
WR2 intmd_linspace (const WR2 &start, const WR2 &end, Size nstep, Size dim=0)
R2 dynamic_linspace (const R2 &start, const R2 &end, Size nstep, Size dim=0)
R2 intmd_linspace (const R2 &start, const R2 &end, Size nstep, Size dim=0)
SR2 dynamic_linspace (const SR2 &start, const SR2 &end, Size nstep, Size dim=0)
SR2 intmd_linspace (const SR2 &start, const SR2 &end, Size nstep, Size dim=0)
R3 dynamic_linspace (const R3 &start, const R3 &end, Size nstep, Size dim=0)
R3 intmd_linspace (const R3 &start, const R3 &end, Size nstep, Size dim=0)
SFR3 dynamic_linspace (const SFR3 &start, const SFR3 &end, Size nstep, Size dim=0)
SFR3 intmd_linspace (const SFR3 &start, const SFR3 &end, Size nstep, Size dim=0)
R4 dynamic_linspace (const R4 &start, const R4 &end, Size nstep, Size dim=0)
R4 intmd_linspace (const R4 &start, const R4 &end, Size nstep, Size dim=0)
SFFR4 dynamic_linspace (const SFFR4 &start, const SFFR4 &end, Size nstep, Size dim=0)
SFFR4 intmd_linspace (const SFFR4 &start, const SFFR4 &end, Size nstep, Size dim=0)
WFFR4 dynamic_linspace (const WFFR4 &start, const WFFR4 &end, Size nstep, Size dim=0)
WFFR4 intmd_linspace (const WFFR4 &start, const WFFR4 &end, Size nstep, Size dim=0)
SSR4 dynamic_linspace (const SSR4 &start, const SSR4 &end, Size nstep, Size dim=0)
SSR4 intmd_linspace (const SSR4 &start, const SSR4 &end, Size nstep, Size dim=0)
SWR4 dynamic_linspace (const SWR4 &start, const SWR4 &end, Size nstep, Size dim=0)
SWR4 intmd_linspace (const SWR4 &start, const SWR4 &end, Size nstep, Size dim=0)
WSR4 dynamic_linspace (const WSR4 &start, const WSR4 &end, Size nstep, Size dim=0)
WSR4 intmd_linspace (const WSR4 &start, const WSR4 &end, Size nstep, Size dim=0)
WWR4 dynamic_linspace (const WWR4 &start, const WWR4 &end, Size nstep, Size dim=0)
WWR4 intmd_linspace (const WWR4 &start, const WWR4 &end, Size nstep, Size dim=0)
Quaternion dynamic_linspace (const Quaternion &start, const Quaternion &end, Size nstep, Size dim=0)
Quaternion intmd_linspace (const Quaternion &start, const Quaternion &end, Size nstep, Size dim=0)
MillerIndex dynamic_linspace (const MillerIndex &start, const MillerIndex &end, Size nstep, Size dim=0)
MillerIndex intmd_linspace (const MillerIndex &start, const MillerIndex &end, Size nstep, Size dim=0)
Tensor dynamic_linspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0)
Tensor intmd_linspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0)
Scalar dynamic_linspace (const Scalar &start, const Scalar &end, Size nstep, Size dim=0)
Scalar intmd_linspace (const Scalar &start, const Scalar &end, Size nstep, Size dim=0)
Tensor base_linspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0)
Vec dynamic_logspace (const Vec &start, const Vec &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Vec intmd_logspace (const Vec &start, const Vec &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Rot dynamic_logspace (const Rot &start, const Rot &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Rot intmd_logspace (const Rot &start, const Rot &end, Size nstep, Size dim=0, const CScalar &base=10.0)
WR2 dynamic_logspace (const WR2 &start, const WR2 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
WR2 intmd_logspace (const WR2 &start, const WR2 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
R2 dynamic_logspace (const R2 &start, const R2 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
R2 intmd_logspace (const R2 &start, const R2 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SR2 dynamic_logspace (const SR2 &start, const SR2 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SR2 intmd_logspace (const SR2 &start, const SR2 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
R3 dynamic_logspace (const R3 &start, const R3 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
R3 intmd_logspace (const R3 &start, const R3 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SFR3 dynamic_logspace (const SFR3 &start, const SFR3 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SFR3 intmd_logspace (const SFR3 &start, const SFR3 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
R4 dynamic_logspace (const R4 &start, const R4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
R4 intmd_logspace (const R4 &start, const R4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SFFR4 dynamic_logspace (const SFFR4 &start, const SFFR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SFFR4 intmd_logspace (const SFFR4 &start, const SFFR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
WFFR4 dynamic_logspace (const WFFR4 &start, const WFFR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
WFFR4 intmd_logspace (const WFFR4 &start, const WFFR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SSR4 dynamic_logspace (const SSR4 &start, const SSR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SSR4 intmd_logspace (const SSR4 &start, const SSR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SWR4 dynamic_logspace (const SWR4 &start, const SWR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
SWR4 intmd_logspace (const SWR4 &start, const SWR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
WSR4 dynamic_logspace (const WSR4 &start, const WSR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
WSR4 intmd_logspace (const WSR4 &start, const WSR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
WWR4 dynamic_logspace (const WWR4 &start, const WWR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
WWR4 intmd_logspace (const WWR4 &start, const WWR4 &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Quaternion dynamic_logspace (const Quaternion &start, const Quaternion &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Quaternion intmd_logspace (const Quaternion &start, const Quaternion &end, Size nstep, Size dim=0, const CScalar &base=10.0)
MillerIndex dynamic_logspace (const MillerIndex &start, const MillerIndex &end, Size nstep, Size dim=0, const CScalar &base=10.0)
MillerIndex intmd_logspace (const MillerIndex &start, const MillerIndex &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Tensor dynamic_logspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Tensor intmd_logspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Scalar dynamic_logspace (const Scalar &start, const Scalar &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Scalar intmd_logspace (const Scalar &start, const Scalar &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Tensor base_logspace (const Tensor &start, const Tensor &end, Size nstep, Size dim=0, const CScalar &base=10.0)
Vec normalize_gcd (const Vec &a)
 Normalize a tensor by its greatest common denominator.
Rot normalize_gcd (const Rot &a)
WR2 normalize_gcd (const WR2 &a)
R2 normalize_gcd (const R2 &a)
SR2 normalize_gcd (const SR2 &a)
R3 normalize_gcd (const R3 &a)
SFR3 normalize_gcd (const SFR3 &a)
R4 normalize_gcd (const R4 &a)
SFFR4 normalize_gcd (const SFFR4 &a)
WFFR4 normalize_gcd (const WFFR4 &a)
SSR4 normalize_gcd (const SSR4 &a)
SWR4 normalize_gcd (const SWR4 &a)
WSR4 normalize_gcd (const WSR4 &a)
WWR4 normalize_gcd (const WWR4 &a)
Quaternion normalize_gcd (const Quaternion &a)
MillerIndex normalize_gcd (const MillerIndex &a)
Tensor normalize_gcd (const Tensor &a)
Scalar normalize_gcd (const Scalar &a)
Tensor outer (const Tensor &, const Tensor &)
Tensor outer (const Tensor &)
R2 outer (const Vec &, const Vec &)
R2 outer (const Vec &)
R4 outer (const R2 &, const R2 &)
R4 outer (const R2 &)
SSR4 outer (const SR2 &, const SR2 &)
SSR4 outer (const SR2 &)
Scalar tr (const Tensor &)
Scalar tr (const R2 &)
Scalar tr (const SR2 &)
Scalar tr (const WR2 &)
Vec unit (const Vec &a, const std::optional< CScalar > &eps=std::nullopt)
Rot unit (const Rot &a, const std::optional< CScalar > &eps=std::nullopt)
WR2 unit (const WR2 &a, const std::optional< CScalar > &eps=std::nullopt)
R2 unit (const R2 &a, const std::optional< CScalar > &eps=std::nullopt)
SR2 unit (const SR2 &a, const std::optional< CScalar > &eps=std::nullopt)
R3 unit (const R3 &a, const std::optional< CScalar > &eps=std::nullopt)
SFR3 unit (const SFR3 &a, const std::optional< CScalar > &eps=std::nullopt)
R4 unit (const R4 &a, const std::optional< CScalar > &eps=std::nullopt)
SFFR4 unit (const SFFR4 &a, const std::optional< CScalar > &eps=std::nullopt)
WFFR4 unit (const WFFR4 &a, const std::optional< CScalar > &eps=std::nullopt)
SSR4 unit (const SSR4 &a, const std::optional< CScalar > &eps=std::nullopt)
SWR4 unit (const SWR4 &a, const std::optional< CScalar > &eps=std::nullopt)
WSR4 unit (const WSR4 &a, const std::optional< CScalar > &eps=std::nullopt)
WWR4 unit (const WWR4 &a, const std::optional< CScalar > &eps=std::nullopt)
Quaternion unit (const Quaternion &a, const std::optional< CScalar > &eps=std::nullopt)
MillerIndex unit (const MillerIndex &a, const std::optional< CScalar > &eps=std::nullopt)
Tensor unit (const Tensor &a, const std::optional< CScalar > &eps=std::nullopt)
Scalar unit (const Scalar &a, const std::optional< CScalar > &eps=std::nullopt)
Tensor vol (const Tensor &)
R2 vol (const R2 &)
SR2 vol (const SR2 &)
WR2 vol (const WR2 &)
TraceableSize operator* (const TraceableSize &lhs, const TraceableSize &rhs)
bool operator== (const TraceableSize &lhs, const TraceableSize &rhs)
bool operator!= (const TraceableSize &lhs, const TraceableSize &rhs)
bool operator== (const TraceableTensorShape &lhs, const TraceableTensorShape &rhs)
bool operator!= (const TraceableTensorShape &lhs, const TraceableTensorShape &rhs)

Variables

const std::string STATE = "state"
const std::string OLD_STATE = "old_state"
const std::string FORCES = "forces"
const std::string OLD_FORCES = "old_forces"
const std::string RESIDUAL = "residual"
const std::string PARAMETERS = "parameters"
constexpr auto kInt8 = c10::kChar
 Fixed width dtypes (mirroring the definition in <torch/csrc/api/include/torch/types.h>).
constexpr auto kInt16 = c10::kShort
constexpr auto kInt32 = c10::kInt
constexpr auto kInt64 = c10::kLong
constexpr auto kFloat16 = c10::kHalf
constexpr auto kFloat32 = c10::kFloat
constexpr auto kFloat64 = c10::kDouble
constexpr auto kCPU = c10::DeviceType::CPU
constexpr auto kCUDA = c10::DeviceType::CUDA
constexpr std::array< std::array< Size, 3 >, 3 > mandel_reverse_index
constexpr std::array< std::array< Size, 2 >, 6 > mandel_index
constexpr std::array< std::array< Size, 3 >, 3 > skew_reverse_index
constexpr std::array< std::array< double, 3 >, 3 > skew_factor
constexpr auto eps = std::numeric_limits<double>::epsilon()
 Constants.
constexpr double sqrt2 = 1.4142135623730951
constexpr double invsqrt2 = 0.7071067811865475
constexpr double pi = M_PI

Typedef Documentation

◆ ArrayRef

template<typename T>
using ArrayRef = c10::ArrayRef<T>

◆ ATensor

using ATensor = at::Tensor

◆ BuildPtr

using BuildPtr = std::shared_ptr<NEML2Object> (*)(const OptionSet & options)

◆ concat_seq_t

template<class Seq1, class Seq2>
using concat_seq_t = typename concat_seq<Seq1, Seq2>::type

◆ CScalar

using CScalar = c10::Scalar

◆ DerivMap

◆ Device

using Device = c10::Device

◆ DeviceIndex

using DeviceIndex = c10::DeviceIndex

◆ DTensorBase_t

template<class Derived, class Seq>
using DTensorBase_t = typename DTensorBase<Derived, Seq>::type

◆ Dtype

using Dtype = c10::ScalarType

◆ json

using json = nlohmann::json

◆ OptionalArrayRef

template<typename T>
using OptionalArrayRef = c10::OptionalArrayRef<T>

◆ R2BackwardEulerTimeIntegration

◆ ScalarBackwardEulerTimeIntegration

◆ SecDerivMap

◆ Size

using Size = int64_t

◆ SmallVector

template<typename T, unsigned N>
using SmallVector = c10::SmallVector<T, N>

◆ SR2BackwardEulerTimeIntegration

◆ SubaxisName

◆ TensorDataContainer

using TensorDataContainer = torch::detail::TensorDataContainer

◆ TensorList

using TensorList = c10::ArrayRef<neml2::Tensor>

◆ TensorOptions

using TensorOptions = c10::TensorOptions

◆ TensorShape

using TensorShape = c10::SmallVector<Size, 8>

◆ TensorShapeRef

using TensorShapeRef = c10::ArrayRef<Size>

◆ ValueMap

using ValueMap = std::map<LabeledAxisAccessor, Tensor>

◆ VariableName

◆ VecBackwardEulerTimeIntegration

Enumeration Type Documentation

◆ ElasticConstant

enum class ElasticConstant : std::uint8_t
strong
Enumerator
INVALID 
LAME_LAMBDA 
BULK_MODULUS 
SHEAR_MODULUS 
YOUNGS_MODULUS 
POISSONS_RATIO 
P_WAVE_MODULUS 
CUBIC_C1 
CUBIC_C2 
CUBIC_C3 

◆ FType

enum class FType : int8_t
strong

Role in a function definition.

NONE is the default value, INPUT stands for input variable, OUTPUT stands for output variable, PARAMETER stands for parameter (could request AD), BUFFER stands for buffer.

Enumerator
NONE 
INPUT 
OUTPUT 
PARAMETER 
BUFFER 

◆ TensorType

enum class TensorType : int8_t
strong
Enumerator
kVec 
kRot 
kWR2 
kR2 
kScalar 
kSR2 
kR3 
kSFR3 
kR4 
kSFFR4 
kWFFR4 
kSSR4 
kSWR4 
kWSR4 
kWWR4 
kQuaternion 
kMillerIndex 
kTensor 
kUknown 

Function Documentation

◆ abs() [1/18]

MillerIndex abs ( const MillerIndex & a)

◆ abs() [2/18]

Quaternion abs ( const Quaternion & a)

◆ abs() [3/18]

R2 abs ( const R2 & a)

◆ abs() [4/18]

R3 abs ( const R3 & a)

◆ abs() [5/18]

R4 abs ( const R4 & a)

◆ abs() [6/18]

Rot abs ( const Rot & a)

◆ abs() [7/18]

Scalar abs ( const Scalar & a)

◆ abs() [8/18]

SFFR4 abs ( const SFFR4 & a)

◆ abs() [9/18]

SFR3 abs ( const SFR3 & a)

◆ abs() [10/18]

SR2 abs ( const SR2 & a)

◆ abs() [11/18]

SSR4 abs ( const SSR4 & a)

◆ abs() [12/18]

SWR4 abs ( const SWR4 & a)

◆ abs() [13/18]

Tensor abs ( const Tensor & a)

◆ abs() [14/18]

Vec abs ( const Vec & a)

◆ abs() [15/18]

WFFR4 abs ( const WFFR4 & a)

◆ abs() [16/18]

WR2 abs ( const WR2 & a)

◆ abs() [17/18]

WSR4 abs ( const WSR4 & a)

◆ abs() [18/18]

WWR4 abs ( const WWR4 & a)

◆ acos() [1/18]

MillerIndex acos ( const MillerIndex & a)

◆ acos() [2/18]

Quaternion acos ( const Quaternion & a)

◆ acos() [3/18]

R2 acos ( const R2 & a)

◆ acos() [4/18]

R3 acos ( const R3 & a)

◆ acos() [5/18]

R4 acos ( const R4 & a)

◆ acos() [6/18]

Rot acos ( const Rot & a)

◆ acos() [7/18]

Scalar acos ( const Scalar & a)

◆ acos() [8/18]

SFFR4 acos ( const SFFR4 & a)

◆ acos() [9/18]

SFR3 acos ( const SFR3 & a)

◆ acos() [10/18]

SR2 acos ( const SR2 & a)

◆ acos() [11/18]

SSR4 acos ( const SSR4 & a)

◆ acos() [12/18]

SWR4 acos ( const SWR4 & a)

◆ acos() [13/18]

Tensor acos ( const Tensor & a)

◆ acos() [14/18]

Vec acos ( const Vec & a)

◆ acos() [15/18]

WFFR4 acos ( const WFFR4 & a)

◆ acos() [16/18]

WR2 acos ( const WR2 & a)

◆ acos() [17/18]

WSR4 acos ( const WSR4 & a)

◆ acos() [18/18]

WWR4 acos ( const WWR4 & a)

◆ apply_mask()

template<typename T>
T apply_mask ( const T & a,
const Scalar & m,
std::size_t mdim )

◆ asin() [1/18]

MillerIndex asin ( const MillerIndex & a)

◆ asin() [2/18]

Quaternion asin ( const Quaternion & a)

◆ asin() [3/18]

R2 asin ( const R2 & a)

◆ asin() [4/18]

R3 asin ( const R3 & a)

◆ asin() [5/18]

R4 asin ( const R4 & a)

◆ asin() [6/18]

Rot asin ( const Rot & a)

◆ asin() [7/18]

Scalar asin ( const Scalar & a)

◆ asin() [8/18]

SFFR4 asin ( const SFFR4 & a)

◆ asin() [9/18]

SFR3 asin ( const SFR3 & a)

◆ asin() [10/18]

SR2 asin ( const SR2 & a)

◆ asin() [11/18]

SSR4 asin ( const SSR4 & a)

◆ asin() [12/18]

SWR4 asin ( const SWR4 & a)

◆ asin() [13/18]

Tensor asin ( const Tensor & a)

◆ asin() [14/18]

Vec asin ( const Vec & a)

◆ asin() [15/18]

WFFR4 asin ( const WFFR4 & a)

◆ asin() [16/18]

WR2 asin ( const WR2 & a)

◆ asin() [17/18]

WSR4 asin ( const WSR4 & a)

◆ asin() [18/18]

WWR4 asin ( const WWR4 & a)

◆ assemble() [1/2]

Tensor assemble ( const SparseTensorList & ,
const std::optional< std::vector< TensorShape > > & intmd_shapes,
const std::vector< TensorShape > & base_shapes )

Assemble a vector of Tensors into a Tensor with one base dimension according to base shapes and optionally intermediate shapes.

◆ assemble() [2/2]

Tensor assemble ( const SparseTensorList & ,
const std::optional< std::vector< TensorShape > > & row_intmd_shapes,
const std::optional< std::vector< TensorShape > > & col_intmd_shapes,
const std::vector< TensorShape > & row_base_shapes,
const std::vector< TensorShape > & col_base_shapes )

Assemble a vector of Tensors (in row-major order) into a Tensor with two base dimension according to base shapes and optionally intermediate shapes.

◆ atan() [1/18]

MillerIndex atan ( const MillerIndex & a)

◆ atan() [2/18]

Quaternion atan ( const Quaternion & a)

◆ atan() [3/18]

R2 atan ( const R2 & a)

◆ atan() [4/18]

R3 atan ( const R3 & a)

◆ atan() [5/18]

R4 atan ( const R4 & a)

◆ atan() [6/18]

Rot atan ( const Rot & a)

◆ atan() [7/18]

Scalar atan ( const Scalar & a)

◆ atan() [8/18]

SFFR4 atan ( const SFFR4 & a)

◆ atan() [9/18]

SFR3 atan ( const SFR3 & a)

◆ atan() [10/18]

SR2 atan ( const SR2 & a)

◆ atan() [11/18]

SSR4 atan ( const SSR4 & a)

◆ atan() [12/18]

SWR4 atan ( const SWR4 & a)

◆ atan() [13/18]

Tensor atan ( const Tensor & a)

◆ atan() [14/18]

Vec atan ( const Vec & a)

◆ atan() [15/18]

WFFR4 atan ( const WFFR4 & a)

◆ atan() [16/18]

WR2 atan ( const WR2 & a)

◆ atan() [17/18]

WSR4 atan ( const WSR4 & a)

◆ atan() [18/18]

WWR4 atan ( const WWR4 & a)

◆ atan2() [1/18]

MillerIndex atan2 ( const MillerIndex & a,
const MillerIndex & b )

◆ atan2() [2/18]

Quaternion atan2 ( const Quaternion & a,
const Quaternion & b )

◆ atan2() [3/18]

R2 atan2 ( const R2 & a,
const R2 & b )

◆ atan2() [4/18]

R3 atan2 ( const R3 & a,
const R3 & b )

◆ atan2() [5/18]

R4 atan2 ( const R4 & a,
const R4 & b )

◆ atan2() [6/18]

Rot atan2 ( const Rot & a,
const Rot & b )

◆ atan2() [7/18]

Scalar atan2 ( const Scalar & a,
const Scalar & b )

◆ atan2() [8/18]

SFFR4 atan2 ( const SFFR4 & a,
const SFFR4 & b )

◆ atan2() [9/18]

SFR3 atan2 ( const SFR3 & a,
const SFR3 & b )

◆ atan2() [10/18]

SR2 atan2 ( const SR2 & a,
const SR2 & b )

◆ atan2() [11/18]

SSR4 atan2 ( const SSR4 & a,
const SSR4 & b )

◆ atan2() [12/18]

SWR4 atan2 ( const SWR4 & a,
const SWR4 & b )

◆ atan2() [13/18]

Tensor atan2 ( const Tensor & a,
const Tensor & b )

◆ atan2() [14/18]

Vec atan2 ( const Vec & a,
const Vec & b )

◆ atan2() [15/18]

WFFR4 atan2 ( const WFFR4 & a,
const WFFR4 & b )

◆ atan2() [16/18]

WR2 atan2 ( const WR2 & a,
const WR2 & b )

◆ atan2() [17/18]

WSR4 atan2 ( const WSR4 & a,
const WSR4 & b )

◆ atan2() [18/18]

WWR4 atan2 ( const WWR4 & a,
const WWR4 & b )

◆ base_argmax() [1/18]

MillerIndex base_argmax ( const MillerIndex & a,
Size dim )

◆ base_argmax() [2/18]

Quaternion base_argmax ( const Quaternion & a,
Size dim )

◆ base_argmax() [3/18]

R2 base_argmax ( const R2 & a,
Size dim )

◆ base_argmax() [4/18]

R3 base_argmax ( const R3 & a,
Size dim )

◆ base_argmax() [5/18]

R4 base_argmax ( const R4 & a,
Size dim )

◆ base_argmax() [6/18]

Rot base_argmax ( const Rot & a,
Size dim )

◆ base_argmax() [7/18]

Scalar base_argmax ( const Scalar & a,
Size dim )

◆ base_argmax() [8/18]

SFFR4 base_argmax ( const SFFR4 & a,
Size dim )

◆ base_argmax() [9/18]

SFR3 base_argmax ( const SFR3 & a,
Size dim )

◆ base_argmax() [10/18]

SR2 base_argmax ( const SR2 & a,
Size dim )

◆ base_argmax() [11/18]

SSR4 base_argmax ( const SSR4 & a,
Size dim )

◆ base_argmax() [12/18]

SWR4 base_argmax ( const SWR4 & a,
Size dim )

◆ base_argmax() [13/18]

Tensor base_argmax ( const Tensor & a,
Size dim )

◆ base_argmax() [14/18]

Vec base_argmax ( const Vec & a,
Size dim )

◆ base_argmax() [15/18]

WFFR4 base_argmax ( const WFFR4 & a,
Size dim )

◆ base_argmax() [16/18]

WR2 base_argmax ( const WR2 & a,
Size dim )

◆ base_argmax() [17/18]

WSR4 base_argmax ( const WSR4 & a,
Size dim )

◆ base_argmax() [18/18]

WWR4 base_argmax ( const WWR4 & a,
Size dim )

◆ base_argmin() [1/18]

MillerIndex base_argmin ( const MillerIndex & a,
Size dim )

◆ base_argmin() [2/18]

Quaternion base_argmin ( const Quaternion & a,
Size dim )

◆ base_argmin() [3/18]

R2 base_argmin ( const R2 & a,
Size dim )

◆ base_argmin() [4/18]

R3 base_argmin ( const R3 & a,
Size dim )

◆ base_argmin() [5/18]

R4 base_argmin ( const R4 & a,
Size dim )

◆ base_argmin() [6/18]

Rot base_argmin ( const Rot & a,
Size dim )

◆ base_argmin() [7/18]

Scalar base_argmin ( const Scalar & a,
Size dim )

◆ base_argmin() [8/18]

SFFR4 base_argmin ( const SFFR4 & a,
Size dim )

◆ base_argmin() [9/18]

SFR3 base_argmin ( const SFR3 & a,
Size dim )

◆ base_argmin() [10/18]

SR2 base_argmin ( const SR2 & a,
Size dim )

◆ base_argmin() [11/18]

SSR4 base_argmin ( const SSR4 & a,
Size dim )

◆ base_argmin() [12/18]

SWR4 base_argmin ( const SWR4 & a,
Size dim )

◆ base_argmin() [13/18]

Tensor base_argmin ( const Tensor & a,
Size dim )

◆ base_argmin() [14/18]

Vec base_argmin ( const Vec & a,
Size dim )

◆ base_argmin() [15/18]

WFFR4 base_argmin ( const WFFR4 & a,
Size dim )

◆ base_argmin() [16/18]

WR2 base_argmin ( const WR2 & a,
Size dim )

◆ base_argmin() [17/18]

WSR4 base_argmin ( const WSR4 & a,
Size dim )

◆ base_argmin() [18/18]

WWR4 base_argmin ( const WWR4 & a,
Size dim )

◆ base_cat()

Tensor base_cat ( const std::vector< Tensor > & tensors,
Size d = 0 )

◆ base_diagonalize()

Tensor base_diagonalize ( const Tensor & a,
Size d = -1 )

◆ base_diff()

neml2::Tensor base_diff ( const Tensor & a,
Size n = 1,
Size dim = -1 )

◆ base_linspace()

Tensor base_linspace ( const Tensor & start,
const Tensor & end,
Size nstep,
Size dim = 0 )

◆ base_logspace()

Tensor base_logspace ( const Tensor & start,
const Tensor & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ base_max()

Tensor base_max ( const Tensor & a,
Size d = 0 )

◆ base_mean()

Tensor base_mean ( const Tensor & a,
Size d = 0 )

◆ base_min()

Tensor base_min ( const Tensor & a,
Size d = 0 )

◆ base_stack()

neml2::Tensor base_stack ( const std::vector< Tensor > & tensors,
Size d = 0 )

◆ base_sum()

Tensor base_sum ( const Tensor & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ base_sum_to_size()

Tensor base_sum_to_size ( const Tensor & a,
TensorShapeRef shape )

◆ bind()

ValueMap bind ( const std::vector< VariableName > & ,
const std::vector< Tensor > &  )

Bind a vector of tensors to variable names.

◆ cbrt() [1/18]

MillerIndex cbrt ( const MillerIndex & a)

◆ cbrt() [2/18]

Quaternion cbrt ( const Quaternion & a)

◆ cbrt() [3/18]

R2 cbrt ( const R2 & a)

◆ cbrt() [4/18]

R3 cbrt ( const R3 & a)

◆ cbrt() [5/18]

R4 cbrt ( const R4 & a)

◆ cbrt() [6/18]

Rot cbrt ( const Rot & a)

◆ cbrt() [7/18]

Scalar cbrt ( const Scalar & a)

◆ cbrt() [8/18]

SFFR4 cbrt ( const SFFR4 & a)

◆ cbrt() [9/18]

SFR3 cbrt ( const SFR3 & a)

◆ cbrt() [10/18]

SR2 cbrt ( const SR2 & a)

◆ cbrt() [11/18]

SSR4 cbrt ( const SSR4 & a)

◆ cbrt() [12/18]

SWR4 cbrt ( const SWR4 & a)

◆ cbrt() [13/18]

Tensor cbrt ( const Tensor & a)

◆ cbrt() [14/18]

Vec cbrt ( const Vec & a)

◆ cbrt() [15/18]

WFFR4 cbrt ( const WFFR4 & a)

◆ cbrt() [16/18]

WR2 cbrt ( const WR2 & a)

◆ cbrt() [17/18]

WSR4 cbrt ( const WSR4 & a)

◆ cbrt() [18/18]

WWR4 cbrt ( const WWR4 & a)

◆ chain_rule() [1/3]

Derivative< 1 > chain_rule ( const Derivative< 1 > & dy_du,
const Derivative< 1 > & du_dx )

Apply chain rule on two first-order derivatives.

◆ chain_rule() [2/3]

Derivative< 2 > chain_rule ( const Derivative< 1 > & dy_du,
const Derivative< 2 > & d2u_dx1x2 )

Apply second order chain rule on dy_du, d2u_dx1x2 In einstein notation: ip, pjk -> ijk

◆ chain_rule() [3/3]

Derivative< 2 > chain_rule ( const Derivative< 2 > & d2y_du1u2,
const Derivative< 1 > * du_dx1,
const Derivative< 1 > * du_dx2 )

Apply second order chain rule on d2y_du1u2, du1_dx1, du2_dx2 In einstein notation: ipq, pj, qk -> ijk

◆ clamp() [1/36]

MillerIndex clamp ( const MillerIndex & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [2/36]

MillerIndex clamp ( const MillerIndex & a,
const MillerIndex & lb,
const MillerIndex & ub )

◆ clamp() [3/36]

Quaternion clamp ( const Quaternion & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [4/36]

Quaternion clamp ( const Quaternion & a,
const Quaternion & lb,
const Quaternion & ub )

◆ clamp() [5/36]

R2 clamp ( const R2 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [6/36]

R2 clamp ( const R2 & a,
const R2 & lb,
const R2 & ub )

◆ clamp() [7/36]

R3 clamp ( const R3 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [8/36]

R3 clamp ( const R3 & a,
const R3 & lb,
const R3 & ub )

◆ clamp() [9/36]

R4 clamp ( const R4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [10/36]

R4 clamp ( const R4 & a,
const R4 & lb,
const R4 & ub )

◆ clamp() [11/36]

Rot clamp ( const Rot & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [12/36]

Rot clamp ( const Rot & a,
const Rot & lb,
const Rot & ub )

◆ clamp() [13/36]

Scalar clamp ( const Scalar & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [14/36]

Scalar clamp ( const Scalar & a,
const Scalar & lb,
const Scalar & ub )

◆ clamp() [15/36]

SFFR4 clamp ( const SFFR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [16/36]

SFFR4 clamp ( const SFFR4 & a,
const SFFR4 & lb,
const SFFR4 & ub )

◆ clamp() [17/36]

SFR3 clamp ( const SFR3 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [18/36]

SFR3 clamp ( const SFR3 & a,
const SFR3 & lb,
const SFR3 & ub )

◆ clamp() [19/36]

SR2 clamp ( const SR2 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [20/36]

SR2 clamp ( const SR2 & a,
const SR2 & lb,
const SR2 & ub )

◆ clamp() [21/36]

SSR4 clamp ( const SSR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [22/36]

SSR4 clamp ( const SSR4 & a,
const SSR4 & lb,
const SSR4 & ub )

◆ clamp() [23/36]

SWR4 clamp ( const SWR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [24/36]

SWR4 clamp ( const SWR4 & a,
const SWR4 & lb,
const SWR4 & ub )

◆ clamp() [25/36]

Tensor clamp ( const Tensor & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [26/36]

Tensor clamp ( const Tensor & a,
const Tensor & lb,
const Tensor & ub )

◆ clamp() [27/36]

Vec clamp ( const Vec & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [28/36]

Vec clamp ( const Vec & a,
const Vec & lb,
const Vec & ub )

◆ clamp() [29/36]

WFFR4 clamp ( const WFFR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [30/36]

WFFR4 clamp ( const WFFR4 & a,
const WFFR4 & lb,
const WFFR4 & ub )

◆ clamp() [31/36]

WR2 clamp ( const WR2 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [32/36]

WR2 clamp ( const WR2 & a,
const WR2 & lb,
const WR2 & ub )

◆ clamp() [33/36]

WSR4 clamp ( const WSR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [34/36]

WSR4 clamp ( const WSR4 & a,
const WSR4 & lb,
const WSR4 & ub )

◆ clamp() [35/36]

WWR4 clamp ( const WWR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clamp() [36/36]

WWR4 clamp ( const WWR4 & a,
const WWR4 & lb,
const WWR4 & ub )

◆ clip() [1/36]

MillerIndex clip ( const MillerIndex & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [2/36]

MillerIndex clip ( const MillerIndex & a,
const MillerIndex & lb,
const MillerIndex & ub )

◆ clip() [3/36]

Quaternion clip ( const Quaternion & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [4/36]

Quaternion clip ( const Quaternion & a,
const Quaternion & lb,
const Quaternion & ub )

◆ clip() [5/36]

R2 clip ( const R2 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [6/36]

R2 clip ( const R2 & a,
const R2 & lb,
const R2 & ub )

◆ clip() [7/36]

R3 clip ( const R3 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [8/36]

R3 clip ( const R3 & a,
const R3 & lb,
const R3 & ub )

◆ clip() [9/36]

R4 clip ( const R4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [10/36]

R4 clip ( const R4 & a,
const R4 & lb,
const R4 & ub )

◆ clip() [11/36]

Rot clip ( const Rot & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [12/36]

Rot clip ( const Rot & a,
const Rot & lb,
const Rot & ub )

◆ clip() [13/36]

Scalar clip ( const Scalar & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [14/36]

Scalar clip ( const Scalar & a,
const Scalar & lb,
const Scalar & ub )

◆ clip() [15/36]

SFFR4 clip ( const SFFR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [16/36]

SFFR4 clip ( const SFFR4 & a,
const SFFR4 & lb,
const SFFR4 & ub )

◆ clip() [17/36]

SFR3 clip ( const SFR3 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [18/36]

SFR3 clip ( const SFR3 & a,
const SFR3 & lb,
const SFR3 & ub )

◆ clip() [19/36]

SR2 clip ( const SR2 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [20/36]

SR2 clip ( const SR2 & a,
const SR2 & lb,
const SR2 & ub )

◆ clip() [21/36]

SSR4 clip ( const SSR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [22/36]

SSR4 clip ( const SSR4 & a,
const SSR4 & lb,
const SSR4 & ub )

◆ clip() [23/36]

SWR4 clip ( const SWR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [24/36]

SWR4 clip ( const SWR4 & a,
const SWR4 & lb,
const SWR4 & ub )

◆ clip() [25/36]

Tensor clip ( const Tensor & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [26/36]

Tensor clip ( const Tensor & a,
const Tensor & lb,
const Tensor & ub )

◆ clip() [27/36]

Vec clip ( const Vec & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [28/36]

Vec clip ( const Vec & a,
const Vec & lb,
const Vec & ub )

◆ clip() [29/36]

WFFR4 clip ( const WFFR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [30/36]

WFFR4 clip ( const WFFR4 & a,
const WFFR4 & lb,
const WFFR4 & ub )

◆ clip() [31/36]

WR2 clip ( const WR2 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [32/36]

WR2 clip ( const WR2 & a,
const WR2 & lb,
const WR2 & ub )

◆ clip() [33/36]

WSR4 clip ( const WSR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [34/36]

WSR4 clip ( const WSR4 & a,
const WSR4 & lb,
const WSR4 & ub )

◆ clip() [35/36]

WWR4 clip ( const WWR4 & a,
const CScalar & lb,
const CScalar & ub )

◆ clip() [36/36]

WWR4 clip ( const WWR4 & a,
const WWR4 & lb,
const WWR4 & ub )

◆ convert_euler_angles_from_kocks()

Vec convert_euler_angles_from_kocks ( const Vec & angles,
const std::string & to_convention )

Convert between Euler angle types.

◆ cos() [1/18]

MillerIndex cos ( const MillerIndex & a)

◆ cos() [2/18]

Quaternion cos ( const Quaternion & a)

◆ cos() [3/18]

R2 cos ( const R2 & a)

◆ cos() [4/18]

R3 cos ( const R3 & a)

◆ cos() [5/18]

R4 cos ( const R4 & a)

◆ cos() [6/18]

Rot cos ( const Rot & a)

◆ cos() [7/18]

Scalar cos ( const Scalar & a)

◆ cos() [8/18]

SFFR4 cos ( const SFFR4 & a)

◆ cos() [9/18]

SFR3 cos ( const SFR3 & a)

◆ cos() [10/18]

SR2 cos ( const SR2 & a)

◆ cos() [11/18]

SSR4 cos ( const SSR4 & a)

◆ cos() [12/18]

SWR4 cos ( const SWR4 & a)

◆ cos() [13/18]

Tensor cos ( const Tensor & a)

◆ cos() [14/18]

Vec cos ( const Vec & a)

◆ cos() [15/18]

WFFR4 cos ( const WFFR4 & a)

◆ cos() [16/18]

WR2 cos ( const WR2 & a)

◆ cos() [17/18]

WSR4 cos ( const WSR4 & a)

◆ cos() [18/18]

WWR4 cos ( const WWR4 & a)

◆ cosh() [1/18]

MillerIndex cosh ( const MillerIndex & a)

◆ cosh() [2/18]

Quaternion cosh ( const Quaternion & a)

◆ cosh() [3/18]

R2 cosh ( const R2 & a)

◆ cosh() [4/18]

R3 cosh ( const R3 & a)

◆ cosh() [5/18]

R4 cosh ( const R4 & a)

◆ cosh() [6/18]

Rot cosh ( const Rot & a)

◆ cosh() [7/18]

Scalar cosh ( const Scalar & a)

◆ cosh() [8/18]

SFFR4 cosh ( const SFFR4 & a)

◆ cosh() [9/18]

SFR3 cosh ( const SFR3 & a)

◆ cosh() [10/18]

SR2 cosh ( const SR2 & a)

◆ cosh() [11/18]

SSR4 cosh ( const SSR4 & a)

◆ cosh() [12/18]

SWR4 cosh ( const SWR4 & a)

◆ cosh() [13/18]

Tensor cosh ( const Tensor & a)

◆ cosh() [14/18]

Vec cosh ( const Vec & a)

◆ cosh() [15/18]

WFFR4 cosh ( const WFFR4 & a)

◆ cosh() [16/18]

WR2 cosh ( const WR2 & a)

◆ cosh() [17/18]

WSR4 cosh ( const WSR4 & a)

◆ cosh() [18/18]

WWR4 cosh ( const WWR4 & a)

◆ cross()

Vec cross ( const Vec & u,
const Vec & v )

◆ current_diagnoses()

std::vector< Diagnosis > & current_diagnoses ( )

Get the current diagnoses.

◆ current_diagnostic_state()

DiagnosticState & current_diagnostic_state ( )

Get the current diagnostic state.

◆ currently_assembling_nonlinear_system()

bool & currently_assembling_nonlinear_system ( )

During the solve of the nonlinear system, we only need derivatives with respect to the unknowns, not w.r.t. the given variables. Therefore, the model can/should avoid unnecessary computations by examining whether the current evaluation is part of the assembly process.

◆ default_integer_tensor_options()

TensorOptions default_integer_tensor_options ( )

Default integral tensor options.

◆ default_tensor_options()

TensorOptions default_tensor_options ( )

Default floating point tensor options.

◆ deg2rad() [1/18]

MillerIndex deg2rad ( const MillerIndex & a)

◆ deg2rad() [2/18]

Quaternion deg2rad ( const Quaternion & a)

◆ deg2rad() [3/18]

R2 deg2rad ( const R2 & a)

◆ deg2rad() [4/18]

R3 deg2rad ( const R3 & a)

◆ deg2rad() [5/18]

R4 deg2rad ( const R4 & a)

◆ deg2rad() [6/18]

Rot deg2rad ( const Rot & a)

◆ deg2rad() [7/18]

Scalar deg2rad ( const Scalar & a)

◆ deg2rad() [8/18]

SFFR4 deg2rad ( const SFFR4 & a)

◆ deg2rad() [9/18]

SFR3 deg2rad ( const SFR3 & a)

◆ deg2rad() [10/18]

SR2 deg2rad ( const SR2 & a)

◆ deg2rad() [11/18]

SSR4 deg2rad ( const SSR4 & a)

◆ deg2rad() [12/18]

SWR4 deg2rad ( const SWR4 & a)

◆ deg2rad() [13/18]

Tensor deg2rad ( const Tensor & a)

◆ deg2rad() [14/18]

Vec deg2rad ( const Vec & a)

◆ deg2rad() [15/18]

WFFR4 deg2rad ( const WFFR4 & a)

◆ deg2rad() [16/18]

WR2 deg2rad ( const WR2 & a)

◆ deg2rad() [17/18]

WSR4 deg2rad ( const WSR4 & a)

◆ deg2rad() [18/18]

WWR4 deg2rad ( const WWR4 & a)

◆ derivative_name()

template<std::size_t N>
std::string derivative_name ( const std::string & var_name,
const std::array< std::string, N > & arg_names )

Pretty print derivative names.

◆ derivmap_cat_reduce()

DerivMap derivmap_cat_reduce ( std::vector< DerivMap > && results,
Size dynamic_dim )

Concatenate the tensors in the DerivMap along the batch dimension.

Parameters
resultsThe results to concatenate
dynamic_dimThe dynamic dimension along which to concatenate
Returns
DerivMap with the tensors concatenated along the dynamic dimension

◆ derivmap_move_device()

DerivMap derivmap_move_device ( DerivMap && x,
Device device )

Move all tensors in a DerivMap to a device.

Parameters
xinput DerivMap
devicetarget device
Returns
DerivMap with all tensors moved

◆ derivmap_no_operation()

DerivMap derivmap_no_operation ( DerivMap && x)

No operation.

◆ det() [1/4]

Scalar det ( const R2 & )

◆ det() [2/4]

Scalar det ( const SR2 & )

◆ det() [3/4]

Scalar det ( const Tensor & )

Determinant of a second order tensor

◆ det() [4/4]

Scalar det ( const WR2 & )

◆ dev() [1/4]

R2 dev ( const R2 & )

◆ dev() [2/4]

SR2 dev ( const SR2 & )

◆ dev() [3/4]

Tensor dev ( const Tensor & )

Deviatoric part of a second order tensor

◆ dev() [4/4]

WR2 dev ( const WR2 & )

◆ diagnose()

std::vector< Diagnosis > diagnose ( const DiagnosticsInterface & )

A helper function to diagnose common setup errors.

◆ diagnose_and_throw()

void diagnose_and_throw ( const DiagnosticsInterface & )

A helper function to diagnose common setup errors and throw an exception if any errors are found.

◆ diagnostic_assert() [1/2]

template<typename... Args>
void diagnostic_assert ( bool assertion,
Args &&... args )

◆ diagnostic_assert() [2/2]

template<typename... Args>
void diagnostic_assert ( bool ,
Args && ... )

Helper assertion function for diagnostics.

◆ disassemble() [1/2]

SparseTensorList disassemble ( const Tensor & ,
const std::optional< std::vector< TensorShape > > & intmd_shapes,
const std::vector< TensorShape > & base_shapes )

Disassemble a Tensor with one base dimension into a vector of Tensors according to base shapes and optionally intermediate shapes.

◆ disassemble() [2/2]

SparseTensorList disassemble ( const Tensor & ,
const std::optional< std::vector< TensorShape > > & row_intmd_shapes,
const std::optional< std::vector< TensorShape > > & col_intmd_shapes,
const std::vector< TensorShape > & row_base_shapes,
const std::vector< TensorShape > & col_base_shapes )

Disassemble (in row-major order) a Tensor with two base dimension into a vector of Tensors according to base shapes and optionally intermediate shapes.

◆ dynamic_argmax() [1/18]

MillerIndex dynamic_argmax ( const MillerIndex & a,
Size dim )

◆ dynamic_argmax() [2/18]

Quaternion dynamic_argmax ( const Quaternion & a,
Size dim )

◆ dynamic_argmax() [3/18]

R2 dynamic_argmax ( const R2 & a,
Size dim )

◆ dynamic_argmax() [4/18]

R3 dynamic_argmax ( const R3 & a,
Size dim )

◆ dynamic_argmax() [5/18]

R4 dynamic_argmax ( const R4 & a,
Size dim )

◆ dynamic_argmax() [6/18]

Rot dynamic_argmax ( const Rot & a,
Size dim )

◆ dynamic_argmax() [7/18]

Scalar dynamic_argmax ( const Scalar & a,
Size dim )

◆ dynamic_argmax() [8/18]

SFFR4 dynamic_argmax ( const SFFR4 & a,
Size dim )

◆ dynamic_argmax() [9/18]

SFR3 dynamic_argmax ( const SFR3 & a,
Size dim )

◆ dynamic_argmax() [10/18]

SR2 dynamic_argmax ( const SR2 & a,
Size dim )

◆ dynamic_argmax() [11/18]

SSR4 dynamic_argmax ( const SSR4 & a,
Size dim )

◆ dynamic_argmax() [12/18]

SWR4 dynamic_argmax ( const SWR4 & a,
Size dim )

◆ dynamic_argmax() [13/18]

Tensor dynamic_argmax ( const Tensor & a,
Size dim )

◆ dynamic_argmax() [14/18]

Vec dynamic_argmax ( const Vec & a,
Size dim )

◆ dynamic_argmax() [15/18]

WFFR4 dynamic_argmax ( const WFFR4 & a,
Size dim )

◆ dynamic_argmax() [16/18]

WR2 dynamic_argmax ( const WR2 & a,
Size dim )

◆ dynamic_argmax() [17/18]

WSR4 dynamic_argmax ( const WSR4 & a,
Size dim )

◆ dynamic_argmax() [18/18]

WWR4 dynamic_argmax ( const WWR4 & a,
Size dim )

◆ dynamic_argmin() [1/18]

MillerIndex dynamic_argmin ( const MillerIndex & a,
Size dim )

◆ dynamic_argmin() [2/18]

Quaternion dynamic_argmin ( const Quaternion & a,
Size dim )

◆ dynamic_argmin() [3/18]

R2 dynamic_argmin ( const R2 & a,
Size dim )

◆ dynamic_argmin() [4/18]

R3 dynamic_argmin ( const R3 & a,
Size dim )

◆ dynamic_argmin() [5/18]

R4 dynamic_argmin ( const R4 & a,
Size dim )

◆ dynamic_argmin() [6/18]

Rot dynamic_argmin ( const Rot & a,
Size dim )

◆ dynamic_argmin() [7/18]

Scalar dynamic_argmin ( const Scalar & a,
Size dim )

◆ dynamic_argmin() [8/18]

SFFR4 dynamic_argmin ( const SFFR4 & a,
Size dim )

◆ dynamic_argmin() [9/18]

SFR3 dynamic_argmin ( const SFR3 & a,
Size dim )

◆ dynamic_argmin() [10/18]

SR2 dynamic_argmin ( const SR2 & a,
Size dim )

◆ dynamic_argmin() [11/18]

SSR4 dynamic_argmin ( const SSR4 & a,
Size dim )

◆ dynamic_argmin() [12/18]

SWR4 dynamic_argmin ( const SWR4 & a,
Size dim )

◆ dynamic_argmin() [13/18]

Tensor dynamic_argmin ( const Tensor & a,
Size dim )

◆ dynamic_argmin() [14/18]

Vec dynamic_argmin ( const Vec & a,
Size dim )

◆ dynamic_argmin() [15/18]

WFFR4 dynamic_argmin ( const WFFR4 & a,
Size dim )

◆ dynamic_argmin() [16/18]

WR2 dynamic_argmin ( const WR2 & a,
Size dim )

◆ dynamic_argmin() [17/18]

WSR4 dynamic_argmin ( const WSR4 & a,
Size dim )

◆ dynamic_argmin() [18/18]

WWR4 dynamic_argmin ( const WWR4 & a,
Size dim )

◆ dynamic_cat() [1/36]

MillerIndex dynamic_cat ( const std::initializer_list< MillerIndex > & tensors,
Size d = 0 )

◆ dynamic_cat() [2/36]

Quaternion dynamic_cat ( const std::initializer_list< Quaternion > & tensors,
Size d = 0 )

◆ dynamic_cat() [3/36]

R2 dynamic_cat ( const std::initializer_list< R2 > & tensors,
Size d = 0 )

◆ dynamic_cat() [4/36]

R3 dynamic_cat ( const std::initializer_list< R3 > & tensors,
Size d = 0 )

◆ dynamic_cat() [5/36]

R4 dynamic_cat ( const std::initializer_list< R4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [6/36]

Rot dynamic_cat ( const std::initializer_list< Rot > & tensors,
Size d = 0 )

◆ dynamic_cat() [7/36]

Scalar dynamic_cat ( const std::initializer_list< Scalar > & tensors,
Size d = 0 )

◆ dynamic_cat() [8/36]

SFFR4 dynamic_cat ( const std::initializer_list< SFFR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [9/36]

SFR3 dynamic_cat ( const std::initializer_list< SFR3 > & tensors,
Size d = 0 )

◆ dynamic_cat() [10/36]

SR2 dynamic_cat ( const std::initializer_list< SR2 > & tensors,
Size d = 0 )

◆ dynamic_cat() [11/36]

SSR4 dynamic_cat ( const std::initializer_list< SSR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [12/36]

SWR4 dynamic_cat ( const std::initializer_list< SWR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [13/36]

Tensor dynamic_cat ( const std::initializer_list< Tensor > & tensors,
Size d = 0 )

◆ dynamic_cat() [14/36]

Vec dynamic_cat ( const std::initializer_list< Vec > & tensors,
Size d = 0 )

◆ dynamic_cat() [15/36]

WFFR4 dynamic_cat ( const std::initializer_list< WFFR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [16/36]

WR2 dynamic_cat ( const std::initializer_list< WR2 > & tensors,
Size d = 0 )

◆ dynamic_cat() [17/36]

WSR4 dynamic_cat ( const std::initializer_list< WSR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [18/36]

WWR4 dynamic_cat ( const std::initializer_list< WWR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [19/36]

MillerIndex dynamic_cat ( const std::vector< MillerIndex > & tensors,
Size d = 0 )

◆ dynamic_cat() [20/36]

Quaternion dynamic_cat ( const std::vector< Quaternion > & tensors,
Size d = 0 )

◆ dynamic_cat() [21/36]

R2 dynamic_cat ( const std::vector< R2 > & tensors,
Size d = 0 )

◆ dynamic_cat() [22/36]

R3 dynamic_cat ( const std::vector< R3 > & tensors,
Size d = 0 )

◆ dynamic_cat() [23/36]

R4 dynamic_cat ( const std::vector< R4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [24/36]

Rot dynamic_cat ( const std::vector< Rot > & tensors,
Size d = 0 )

◆ dynamic_cat() [25/36]

Scalar dynamic_cat ( const std::vector< Scalar > & tensors,
Size d = 0 )

◆ dynamic_cat() [26/36]

SFFR4 dynamic_cat ( const std::vector< SFFR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [27/36]

SFR3 dynamic_cat ( const std::vector< SFR3 > & tensors,
Size d = 0 )

◆ dynamic_cat() [28/36]

SR2 dynamic_cat ( const std::vector< SR2 > & tensors,
Size d = 0 )

◆ dynamic_cat() [29/36]

SSR4 dynamic_cat ( const std::vector< SSR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [30/36]

SWR4 dynamic_cat ( const std::vector< SWR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [31/36]

Tensor dynamic_cat ( const std::vector< Tensor > & tensors,
Size d = 0 )

◆ dynamic_cat() [32/36]

Vec dynamic_cat ( const std::vector< Vec > & tensors,
Size d = 0 )

◆ dynamic_cat() [33/36]

WFFR4 dynamic_cat ( const std::vector< WFFR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [34/36]

WR2 dynamic_cat ( const std::vector< WR2 > & tensors,
Size d = 0 )

◆ dynamic_cat() [35/36]

WSR4 dynamic_cat ( const std::vector< WSR4 > & tensors,
Size d = 0 )

◆ dynamic_cat() [36/36]

WWR4 dynamic_cat ( const std::vector< WWR4 > & tensors,
Size d = 0 )

◆ dynamic_diagonalize() [1/18]

MillerIndex dynamic_diagonalize ( const MillerIndex & a,
Size d = -1 )

◆ dynamic_diagonalize() [2/18]

Quaternion dynamic_diagonalize ( const Quaternion & a,
Size d = -1 )

◆ dynamic_diagonalize() [3/18]

R2 dynamic_diagonalize ( const R2 & a,
Size d = -1 )

◆ dynamic_diagonalize() [4/18]

R3 dynamic_diagonalize ( const R3 & a,
Size d = -1 )

◆ dynamic_diagonalize() [5/18]

R4 dynamic_diagonalize ( const R4 & a,
Size d = -1 )

◆ dynamic_diagonalize() [6/18]

Rot dynamic_diagonalize ( const Rot & a,
Size d = -1 )

◆ dynamic_diagonalize() [7/18]

Scalar dynamic_diagonalize ( const Scalar & a,
Size d = -1 )

◆ dynamic_diagonalize() [8/18]

SFFR4 dynamic_diagonalize ( const SFFR4 & a,
Size d = -1 )

◆ dynamic_diagonalize() [9/18]

SFR3 dynamic_diagonalize ( const SFR3 & a,
Size d = -1 )

◆ dynamic_diagonalize() [10/18]

SR2 dynamic_diagonalize ( const SR2 & a,
Size d = -1 )

◆ dynamic_diagonalize() [11/18]

SSR4 dynamic_diagonalize ( const SSR4 & a,
Size d = -1 )

◆ dynamic_diagonalize() [12/18]

SWR4 dynamic_diagonalize ( const SWR4 & a,
Size d = -1 )

◆ dynamic_diagonalize() [13/18]

Tensor dynamic_diagonalize ( const Tensor & a,
Size d = -1 )

◆ dynamic_diagonalize() [14/18]

Vec dynamic_diagonalize ( const Vec & a,
Size d = -1 )

◆ dynamic_diagonalize() [15/18]

WFFR4 dynamic_diagonalize ( const WFFR4 & a,
Size d = -1 )

◆ dynamic_diagonalize() [16/18]

WR2 dynamic_diagonalize ( const WR2 & a,
Size d = -1 )

◆ dynamic_diagonalize() [17/18]

WSR4 dynamic_diagonalize ( const WSR4 & a,
Size d = -1 )

◆ dynamic_diagonalize() [18/18]

WWR4 dynamic_diagonalize ( const WWR4 & a,
Size d = -1 )

◆ dynamic_diff() [1/18]

MillerIndex dynamic_diff ( const MillerIndex & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [2/18]

Quaternion dynamic_diff ( const Quaternion & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [3/18]

R2 dynamic_diff ( const R2 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [4/18]

R3 dynamic_diff ( const R3 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [5/18]

R4 dynamic_diff ( const R4 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [6/18]

Rot dynamic_diff ( const Rot & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [7/18]

Scalar dynamic_diff ( const Scalar & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [8/18]

SFFR4 dynamic_diff ( const SFFR4 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [9/18]

SFR3 dynamic_diff ( const SFR3 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [10/18]

SR2 dynamic_diff ( const SR2 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [11/18]

SSR4 dynamic_diff ( const SSR4 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [12/18]

SWR4 dynamic_diff ( const SWR4 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [13/18]

Tensor dynamic_diff ( const Tensor & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [14/18]

Vec dynamic_diff ( const Vec & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [15/18]

WFFR4 dynamic_diff ( const WFFR4 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [16/18]

WR2 dynamic_diff ( const WR2 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [17/18]

WSR4 dynamic_diff ( const WSR4 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_diff() [18/18]

WWR4 dynamic_diff ( const WWR4 & a,
Size n = 1,
Size dim = -1 )

◆ dynamic_linspace() [1/18]

MillerIndex dynamic_linspace ( const MillerIndex & start,
const MillerIndex & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [2/18]

Quaternion dynamic_linspace ( const Quaternion & start,
const Quaternion & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [3/18]

R2 dynamic_linspace ( const R2 & start,
const R2 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [4/18]

R3 dynamic_linspace ( const R3 & start,
const R3 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [5/18]

R4 dynamic_linspace ( const R4 & start,
const R4 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [6/18]

Rot dynamic_linspace ( const Rot & start,
const Rot & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [7/18]

Scalar dynamic_linspace ( const Scalar & start,
const Scalar & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [8/18]

SFFR4 dynamic_linspace ( const SFFR4 & start,
const SFFR4 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [9/18]

SFR3 dynamic_linspace ( const SFR3 & start,
const SFR3 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [10/18]

SR2 dynamic_linspace ( const SR2 & start,
const SR2 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [11/18]

SSR4 dynamic_linspace ( const SSR4 & start,
const SSR4 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [12/18]

SWR4 dynamic_linspace ( const SWR4 & start,
const SWR4 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [13/18]

Tensor dynamic_linspace ( const Tensor & start,
const Tensor & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [14/18]

Vec dynamic_linspace ( const Vec & start,
const Vec & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [15/18]

WFFR4 dynamic_linspace ( const WFFR4 & start,
const WFFR4 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [16/18]

WR2 dynamic_linspace ( const WR2 & start,
const WR2 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [17/18]

WSR4 dynamic_linspace ( const WSR4 & start,
const WSR4 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_linspace() [18/18]

WWR4 dynamic_linspace ( const WWR4 & start,
const WWR4 & end,
Size nstep,
Size dim = 0 )

◆ dynamic_logspace() [1/18]

MillerIndex dynamic_logspace ( const MillerIndex & start,
const MillerIndex & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [2/18]

Quaternion dynamic_logspace ( const Quaternion & start,
const Quaternion & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [3/18]

R2 dynamic_logspace ( const R2 & start,
const R2 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [4/18]

R3 dynamic_logspace ( const R3 & start,
const R3 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [5/18]

R4 dynamic_logspace ( const R4 & start,
const R4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [6/18]

Rot dynamic_logspace ( const Rot & start,
const Rot & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [7/18]

Scalar dynamic_logspace ( const Scalar & start,
const Scalar & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [8/18]

SFFR4 dynamic_logspace ( const SFFR4 & start,
const SFFR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [9/18]

SFR3 dynamic_logspace ( const SFR3 & start,
const SFR3 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [10/18]

SR2 dynamic_logspace ( const SR2 & start,
const SR2 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [11/18]

SSR4 dynamic_logspace ( const SSR4 & start,
const SSR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [12/18]

SWR4 dynamic_logspace ( const SWR4 & start,
const SWR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [13/18]

Tensor dynamic_logspace ( const Tensor & start,
const Tensor & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [14/18]

Vec dynamic_logspace ( const Vec & start,
const Vec & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [15/18]

WFFR4 dynamic_logspace ( const WFFR4 & start,
const WFFR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [16/18]

WR2 dynamic_logspace ( const WR2 & start,
const WR2 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [17/18]

WSR4 dynamic_logspace ( const WSR4 & start,
const WSR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_logspace() [18/18]

WWR4 dynamic_logspace ( const WWR4 & start,
const WWR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ dynamic_max() [1/18]

MillerIndex dynamic_max ( const MillerIndex & a,
Size d = 0 )

◆ dynamic_max() [2/18]

Quaternion dynamic_max ( const Quaternion & a,
Size d = 0 )

◆ dynamic_max() [3/18]

R2 dynamic_max ( const R2 & a,
Size d = 0 )

◆ dynamic_max() [4/18]

R3 dynamic_max ( const R3 & a,
Size d = 0 )

◆ dynamic_max() [5/18]

R4 dynamic_max ( const R4 & a,
Size d = 0 )

◆ dynamic_max() [6/18]

Rot dynamic_max ( const Rot & a,
Size d = 0 )

◆ dynamic_max() [7/18]

Scalar dynamic_max ( const Scalar & a,
Size d = 0 )

◆ dynamic_max() [8/18]

SFFR4 dynamic_max ( const SFFR4 & a,
Size d = 0 )

◆ dynamic_max() [9/18]

SFR3 dynamic_max ( const SFR3 & a,
Size d = 0 )

◆ dynamic_max() [10/18]

SR2 dynamic_max ( const SR2 & a,
Size d = 0 )

◆ dynamic_max() [11/18]

SSR4 dynamic_max ( const SSR4 & a,
Size d = 0 )

◆ dynamic_max() [12/18]

SWR4 dynamic_max ( const SWR4 & a,
Size d = 0 )

◆ dynamic_max() [13/18]

Tensor dynamic_max ( const Tensor & a,
Size d = 0 )

◆ dynamic_max() [14/18]

Vec dynamic_max ( const Vec & a,
Size d = 0 )

◆ dynamic_max() [15/18]

WFFR4 dynamic_max ( const WFFR4 & a,
Size d = 0 )

◆ dynamic_max() [16/18]

WR2 dynamic_max ( const WR2 & a,
Size d = 0 )

◆ dynamic_max() [17/18]

WSR4 dynamic_max ( const WSR4 & a,
Size d = 0 )

◆ dynamic_max() [18/18]

WWR4 dynamic_max ( const WWR4 & a,
Size d = 0 )

◆ dynamic_mean() [1/18]

MillerIndex dynamic_mean ( const MillerIndex & a,
Size d = 0 )

◆ dynamic_mean() [2/18]

Quaternion dynamic_mean ( const Quaternion & a,
Size d = 0 )

◆ dynamic_mean() [3/18]

R2 dynamic_mean ( const R2 & a,
Size d = 0 )

◆ dynamic_mean() [4/18]

R3 dynamic_mean ( const R3 & a,
Size d = 0 )

◆ dynamic_mean() [5/18]

R4 dynamic_mean ( const R4 & a,
Size d = 0 )

◆ dynamic_mean() [6/18]

Rot dynamic_mean ( const Rot & a,
Size d = 0 )

◆ dynamic_mean() [7/18]

Scalar dynamic_mean ( const Scalar & a,
Size d = 0 )

◆ dynamic_mean() [8/18]

SFFR4 dynamic_mean ( const SFFR4 & a,
Size d = 0 )

◆ dynamic_mean() [9/18]

SFR3 dynamic_mean ( const SFR3 & a,
Size d = 0 )

◆ dynamic_mean() [10/18]

SR2 dynamic_mean ( const SR2 & a,
Size d = 0 )

◆ dynamic_mean() [11/18]

SSR4 dynamic_mean ( const SSR4 & a,
Size d = 0 )

◆ dynamic_mean() [12/18]

SWR4 dynamic_mean ( const SWR4 & a,
Size d = 0 )

◆ dynamic_mean() [13/18]

Tensor dynamic_mean ( const Tensor & a,
Size d = 0 )

◆ dynamic_mean() [14/18]

Vec dynamic_mean ( const Vec & a,
Size d = 0 )

◆ dynamic_mean() [15/18]

WFFR4 dynamic_mean ( const WFFR4 & a,
Size d = 0 )

◆ dynamic_mean() [16/18]

WR2 dynamic_mean ( const WR2 & a,
Size d = 0 )

◆ dynamic_mean() [17/18]

WSR4 dynamic_mean ( const WSR4 & a,
Size d = 0 )

◆ dynamic_mean() [18/18]

WWR4 dynamic_mean ( const WWR4 & a,
Size d = 0 )

◆ dynamic_min() [1/18]

MillerIndex dynamic_min ( const MillerIndex & a,
Size d = 0 )

◆ dynamic_min() [2/18]

Quaternion dynamic_min ( const Quaternion & a,
Size d = 0 )

◆ dynamic_min() [3/18]

R2 dynamic_min ( const R2 & a,
Size d = 0 )

◆ dynamic_min() [4/18]

R3 dynamic_min ( const R3 & a,
Size d = 0 )

◆ dynamic_min() [5/18]

R4 dynamic_min ( const R4 & a,
Size d = 0 )

◆ dynamic_min() [6/18]

Rot dynamic_min ( const Rot & a,
Size d = 0 )

◆ dynamic_min() [7/18]

Scalar dynamic_min ( const Scalar & a,
Size d = 0 )

◆ dynamic_min() [8/18]

SFFR4 dynamic_min ( const SFFR4 & a,
Size d = 0 )

◆ dynamic_min() [9/18]

SFR3 dynamic_min ( const SFR3 & a,
Size d = 0 )

◆ dynamic_min() [10/18]

SR2 dynamic_min ( const SR2 & a,
Size d = 0 )

◆ dynamic_min() [11/18]

SSR4 dynamic_min ( const SSR4 & a,
Size d = 0 )

◆ dynamic_min() [12/18]

SWR4 dynamic_min ( const SWR4 & a,
Size d = 0 )

◆ dynamic_min() [13/18]

Tensor dynamic_min ( const Tensor & a,
Size d = 0 )

◆ dynamic_min() [14/18]

Vec dynamic_min ( const Vec & a,
Size d = 0 )

◆ dynamic_min() [15/18]

WFFR4 dynamic_min ( const WFFR4 & a,
Size d = 0 )

◆ dynamic_min() [16/18]

WR2 dynamic_min ( const WR2 & a,
Size d = 0 )

◆ dynamic_min() [17/18]

WSR4 dynamic_min ( const WSR4 & a,
Size d = 0 )

◆ dynamic_min() [18/18]

WWR4 dynamic_min ( const WWR4 & a,
Size d = 0 )

◆ dynamic_stack() [1/36]

MillerIndex dynamic_stack ( const std::initializer_list< MillerIndex > & tensors,
Size d = 0 )

◆ dynamic_stack() [2/36]

Quaternion dynamic_stack ( const std::initializer_list< Quaternion > & tensors,
Size d = 0 )

◆ dynamic_stack() [3/36]

R2 dynamic_stack ( const std::initializer_list< R2 > & tensors,
Size d = 0 )

◆ dynamic_stack() [4/36]

R3 dynamic_stack ( const std::initializer_list< R3 > & tensors,
Size d = 0 )

◆ dynamic_stack() [5/36]

R4 dynamic_stack ( const std::initializer_list< R4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [6/36]

Rot dynamic_stack ( const std::initializer_list< Rot > & tensors,
Size d = 0 )

◆ dynamic_stack() [7/36]

Scalar dynamic_stack ( const std::initializer_list< Scalar > & tensors,
Size d = 0 )

◆ dynamic_stack() [8/36]

SFFR4 dynamic_stack ( const std::initializer_list< SFFR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [9/36]

SFR3 dynamic_stack ( const std::initializer_list< SFR3 > & tensors,
Size d = 0 )

◆ dynamic_stack() [10/36]

SR2 dynamic_stack ( const std::initializer_list< SR2 > & tensors,
Size d = 0 )

◆ dynamic_stack() [11/36]

SSR4 dynamic_stack ( const std::initializer_list< SSR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [12/36]

SWR4 dynamic_stack ( const std::initializer_list< SWR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [13/36]

Tensor dynamic_stack ( const std::initializer_list< Tensor > & tensors,
Size d = 0 )

◆ dynamic_stack() [14/36]

Vec dynamic_stack ( const std::initializer_list< Vec > & tensors,
Size d = 0 )

◆ dynamic_stack() [15/36]

WFFR4 dynamic_stack ( const std::initializer_list< WFFR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [16/36]

WR2 dynamic_stack ( const std::initializer_list< WR2 > & tensors,
Size d = 0 )

◆ dynamic_stack() [17/36]

WSR4 dynamic_stack ( const std::initializer_list< WSR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [18/36]

WWR4 dynamic_stack ( const std::initializer_list< WWR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [19/36]

MillerIndex dynamic_stack ( const std::vector< MillerIndex > & tensors,
Size d = 0 )

◆ dynamic_stack() [20/36]

Quaternion dynamic_stack ( const std::vector< Quaternion > & tensors,
Size d = 0 )

◆ dynamic_stack() [21/36]

R2 dynamic_stack ( const std::vector< R2 > & tensors,
Size d = 0 )

◆ dynamic_stack() [22/36]

R3 dynamic_stack ( const std::vector< R3 > & tensors,
Size d = 0 )

◆ dynamic_stack() [23/36]

R4 dynamic_stack ( const std::vector< R4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [24/36]

Rot dynamic_stack ( const std::vector< Rot > & tensors,
Size d = 0 )

◆ dynamic_stack() [25/36]

Scalar dynamic_stack ( const std::vector< Scalar > & tensors,
Size d = 0 )

◆ dynamic_stack() [26/36]

SFFR4 dynamic_stack ( const std::vector< SFFR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [27/36]

SFR3 dynamic_stack ( const std::vector< SFR3 > & tensors,
Size d = 0 )

◆ dynamic_stack() [28/36]

SR2 dynamic_stack ( const std::vector< SR2 > & tensors,
Size d = 0 )

◆ dynamic_stack() [29/36]

SSR4 dynamic_stack ( const std::vector< SSR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [30/36]

SWR4 dynamic_stack ( const std::vector< SWR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [31/36]

Tensor dynamic_stack ( const std::vector< Tensor > & tensors,
Size d = 0 )

◆ dynamic_stack() [32/36]

Vec dynamic_stack ( const std::vector< Vec > & tensors,
Size d = 0 )

◆ dynamic_stack() [33/36]

WFFR4 dynamic_stack ( const std::vector< WFFR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [34/36]

WR2 dynamic_stack ( const std::vector< WR2 > & tensors,
Size d = 0 )

◆ dynamic_stack() [35/36]

WSR4 dynamic_stack ( const std::vector< WSR4 > & tensors,
Size d = 0 )

◆ dynamic_stack() [36/36]

WWR4 dynamic_stack ( const std::vector< WWR4 > & tensors,
Size d = 0 )

◆ dynamic_sum() [1/18]

MillerIndex dynamic_sum ( const MillerIndex & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [2/18]

Quaternion dynamic_sum ( const Quaternion & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [3/18]

R2 dynamic_sum ( const R2 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [4/18]

R3 dynamic_sum ( const R3 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [5/18]

R4 dynamic_sum ( const R4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [6/18]

Rot dynamic_sum ( const Rot & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [7/18]

Scalar dynamic_sum ( const Scalar & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [8/18]

SFFR4 dynamic_sum ( const SFFR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [9/18]

SFR3 dynamic_sum ( const SFR3 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [10/18]

SR2 dynamic_sum ( const SR2 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [11/18]

SSR4 dynamic_sum ( const SSR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [12/18]

SWR4 dynamic_sum ( const SWR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [13/18]

Tensor dynamic_sum ( const Tensor & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [14/18]

Vec dynamic_sum ( const Vec & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [15/18]

WFFR4 dynamic_sum ( const WFFR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [16/18]

WR2 dynamic_sum ( const WR2 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [17/18]

WSR4 dynamic_sum ( const WSR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum() [18/18]

WWR4 dynamic_sum ( const WWR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ dynamic_sum_to_size() [1/18]

MillerIndex dynamic_sum_to_size ( const MillerIndex & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [2/18]

Quaternion dynamic_sum_to_size ( const Quaternion & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [3/18]

R2 dynamic_sum_to_size ( const R2 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [4/18]

R3 dynamic_sum_to_size ( const R3 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [5/18]

R4 dynamic_sum_to_size ( const R4 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [6/18]

Rot dynamic_sum_to_size ( const Rot & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [7/18]

Scalar dynamic_sum_to_size ( const Scalar & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [8/18]

SFFR4 dynamic_sum_to_size ( const SFFR4 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [9/18]

SFR3 dynamic_sum_to_size ( const SFR3 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [10/18]

SR2 dynamic_sum_to_size ( const SR2 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [11/18]

SSR4 dynamic_sum_to_size ( const SSR4 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [12/18]

SWR4 dynamic_sum_to_size ( const SWR4 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [13/18]

Tensor dynamic_sum_to_size ( const Tensor & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [14/18]

Vec dynamic_sum_to_size ( const Vec & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [15/18]

WFFR4 dynamic_sum_to_size ( const WFFR4 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [16/18]

WR2 dynamic_sum_to_size ( const WR2 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [17/18]

WSR4 dynamic_sum_to_size ( const WSR4 & a,
const TraceableTensorShape & shape )

◆ dynamic_sum_to_size() [18/18]

WWR4 dynamic_sum_to_size ( const WWR4 & a,
const TraceableTensorShape & shape )

◆ einsum()

Tensor einsum ( c10::string_view equation,
TensorList tensors )

Einstein summation along base dimensions.

◆ eq() [1/88]

MillerIndex eq ( const CScalar & a,
const MillerIndex & b )

◆ eq() [2/88]

Quaternion eq ( const CScalar & a,
const Quaternion & b )

◆ eq() [3/88]

R2 eq ( const CScalar & a,
const R2 & b )

◆ eq() [4/88]

R3 eq ( const CScalar & a,
const R3 & b )

◆ eq() [5/88]

R4 eq ( const CScalar & a,
const R4 & b )

◆ eq() [6/88]

Rot eq ( const CScalar & a,
const Rot & b )

◆ eq() [7/88]

Scalar eq ( const CScalar & a,
const Scalar & b )

◆ eq() [8/88]

SFFR4 eq ( const CScalar & a,
const SFFR4 & b )

◆ eq() [9/88]

SFR3 eq ( const CScalar & a,
const SFR3 & b )

◆ eq() [10/88]

SR2 eq ( const CScalar & a,
const SR2 & b )

◆ eq() [11/88]

SSR4 eq ( const CScalar & a,
const SSR4 & b )

◆ eq() [12/88]

SWR4 eq ( const CScalar & a,
const SWR4 & b )

◆ eq() [13/88]

Tensor eq ( const CScalar & a,
const Tensor & b )

◆ eq() [14/88]

Vec eq ( const CScalar & a,
const Vec & b )

◆ eq() [15/88]

WFFR4 eq ( const CScalar & a,
const WFFR4 & b )

◆ eq() [16/88]

WR2 eq ( const CScalar & a,
const WR2 & b )

◆ eq() [17/88]

WSR4 eq ( const CScalar & a,
const WSR4 & b )

◆ eq() [18/88]

WWR4 eq ( const CScalar & a,
const WWR4 & b )

◆ eq() [19/88]

MillerIndex eq ( const MillerIndex & a,
const CScalar & b )

◆ eq() [20/88]

MillerIndex eq ( const MillerIndex & a,
const MillerIndex & b )

◆ eq() [21/88]

MillerIndex eq ( const MillerIndex & a,
const Scalar & b )

◆ eq() [22/88]

Quaternion eq ( const Quaternion & a,
const CScalar & b )

◆ eq() [23/88]

Quaternion eq ( const Quaternion & a,
const Quaternion & b )

◆ eq() [24/88]

Quaternion eq ( const Quaternion & a,
const Scalar & b )

◆ eq() [25/88]

R2 eq ( const R2 & a,
const CScalar & b )

◆ eq() [26/88]

R2 eq ( const R2 & a,
const R2 & b )

◆ eq() [27/88]

R2 eq ( const R2 & a,
const Scalar & b )

◆ eq() [28/88]

R3 eq ( const R3 & a,
const CScalar & b )

◆ eq() [29/88]

R3 eq ( const R3 & a,
const R3 & b )

◆ eq() [30/88]

R3 eq ( const R3 & a,
const Scalar & b )

◆ eq() [31/88]

R4 eq ( const R4 & a,
const CScalar & b )

◆ eq() [32/88]

R4 eq ( const R4 & a,
const R4 & b )

◆ eq() [33/88]

R4 eq ( const R4 & a,
const Scalar & b )

◆ eq() [34/88]

Rot eq ( const Rot & a,
const CScalar & b )

◆ eq() [35/88]

Rot eq ( const Rot & a,
const Rot & b )

◆ eq() [36/88]

Rot eq ( const Rot & a,
const Scalar & b )

◆ eq() [37/88]

Scalar eq ( const Scalar & a,
const CScalar & b )

◆ eq() [38/88]

MillerIndex eq ( const Scalar & a,
const MillerIndex & b )

◆ eq() [39/88]

Quaternion eq ( const Scalar & a,
const Quaternion & b )

◆ eq() [40/88]

R2 eq ( const Scalar & a,
const R2 & b )

◆ eq() [41/88]

R3 eq ( const Scalar & a,
const R3 & b )

◆ eq() [42/88]

R4 eq ( const Scalar & a,
const R4 & b )

◆ eq() [43/88]

Rot eq ( const Scalar & a,
const Rot & b )

◆ eq() [44/88]

Scalar eq ( const Scalar & a,
const Scalar & b )

◆ eq() [45/88]

SFFR4 eq ( const Scalar & a,
const SFFR4 & b )

◆ eq() [46/88]

SFR3 eq ( const Scalar & a,
const SFR3 & b )

◆ eq() [47/88]

SR2 eq ( const Scalar & a,
const SR2 & b )

◆ eq() [48/88]

SSR4 eq ( const Scalar & a,
const SSR4 & b )

◆ eq() [49/88]

SWR4 eq ( const Scalar & a,
const SWR4 & b )

◆ eq() [50/88]

Tensor eq ( const Scalar & a,
const Tensor & b )

◆ eq() [51/88]

Vec eq ( const Scalar & a,
const Vec & b )

◆ eq() [52/88]

WFFR4 eq ( const Scalar & a,
const WFFR4 & b )

◆ eq() [53/88]

WR2 eq ( const Scalar & a,
const WR2 & b )

◆ eq() [54/88]

WSR4 eq ( const Scalar & a,
const WSR4 & b )

◆ eq() [55/88]

WWR4 eq ( const Scalar & a,
const WWR4 & b )

◆ eq() [56/88]

SFFR4 eq ( const SFFR4 & a,
const CScalar & b )

◆ eq() [57/88]

SFFR4 eq ( const SFFR4 & a,
const Scalar & b )

◆ eq() [58/88]

SFFR4 eq ( const SFFR4 & a,
const SFFR4 & b )

◆ eq() [59/88]

SFR3 eq ( const SFR3 & a,
const CScalar & b )

◆ eq() [60/88]

SFR3 eq ( const SFR3 & a,
const Scalar & b )

◆ eq() [61/88]

SFR3 eq ( const SFR3 & a,
const SFR3 & b )

◆ eq() [62/88]

SR2 eq ( const SR2 & a,
const CScalar & b )

◆ eq() [63/88]

SR2 eq ( const SR2 & a,
const Scalar & b )

◆ eq() [64/88]

SR2 eq ( const SR2 & a,
const SR2 & b )

◆ eq() [65/88]

SSR4 eq ( const SSR4 & a,
const CScalar & b )

◆ eq() [66/88]

SSR4 eq ( const SSR4 & a,
const Scalar & b )

◆ eq() [67/88]

SSR4 eq ( const SSR4 & a,
const SSR4 & b )

◆ eq() [68/88]

SWR4 eq ( const SWR4 & a,
const CScalar & b )

◆ eq() [69/88]

SWR4 eq ( const SWR4 & a,
const Scalar & b )

◆ eq() [70/88]

SWR4 eq ( const SWR4 & a,
const SWR4 & b )

◆ eq() [71/88]

Tensor eq ( const Tensor & a,
const CScalar & b )

◆ eq() [72/88]

Tensor eq ( const Tensor & a,
const Scalar & b )

◆ eq() [73/88]

Tensor eq ( const Tensor & a,
const Tensor & b )

◆ eq() [74/88]

Vec eq ( const Vec & a,
const CScalar & b )

◆ eq() [75/88]

Vec eq ( const Vec & a,
const Scalar & b )

◆ eq() [76/88]

Vec eq ( const Vec & a,
const Vec & b )

◆ eq() [77/88]

WFFR4 eq ( const WFFR4 & a,
const CScalar & b )

◆ eq() [78/88]

WFFR4 eq ( const WFFR4 & a,
const Scalar & b )

◆ eq() [79/88]

WFFR4 eq ( const WFFR4 & a,
const WFFR4 & b )

◆ eq() [80/88]

WR2 eq ( const WR2 & a,
const CScalar & b )

◆ eq() [81/88]

WR2 eq ( const WR2 & a,
const Scalar & b )

◆ eq() [82/88]

WR2 eq ( const WR2 & a,
const WR2 & b )

◆ eq() [83/88]

WSR4 eq ( const WSR4 & a,
const CScalar & b )

◆ eq() [84/88]

WSR4 eq ( const WSR4 & a,
const Scalar & b )

◆ eq() [85/88]

WSR4 eq ( const WSR4 & a,
const WSR4 & b )

◆ eq() [86/88]

WWR4 eq ( const WWR4 & a,
const CScalar & b )

◆ eq() [87/88]

WWR4 eq ( const WWR4 & a,
const Scalar & b )

◆ eq() [88/88]

WWR4 eq ( const WWR4 & a,
const WWR4 & b )

◆ event_trace_writers()

std::unordered_map< std::string, std::unique_ptr< TraceWriter > > & event_trace_writers ( )

All trace writers.

◆ exp() [1/18]

MillerIndex exp ( const MillerIndex & a)

◆ exp() [2/18]

Quaternion exp ( const Quaternion & a)

◆ exp() [3/18]

R2 exp ( const R2 & a)

◆ exp() [4/18]

R3 exp ( const R3 & a)

◆ exp() [5/18]

R4 exp ( const R4 & a)

◆ exp() [6/18]

Rot exp ( const Rot & a)

◆ exp() [7/18]

Scalar exp ( const Scalar & a)

◆ exp() [8/18]

SFFR4 exp ( const SFFR4 & a)

◆ exp() [9/18]

SFR3 exp ( const SFR3 & a)

◆ exp() [10/18]

SR2 exp ( const SR2 & a)

◆ exp() [11/18]

SSR4 exp ( const SSR4 & a)

◆ exp() [12/18]

SWR4 exp ( const SWR4 & a)

◆ exp() [13/18]

Tensor exp ( const Tensor & a)

◆ exp() [14/18]

Vec exp ( const Vec & a)

◆ exp() [15/18]

WFFR4 exp ( const WFFR4 & a)

◆ exp() [16/18]

WR2 exp ( const WR2 & a)

◆ exp() [17/18]

WSR4 exp ( const WSR4 & a)

◆ exp() [18/18]

WWR4 exp ( const WWR4 & a)

◆ fmod() [1/36]

MillerIndex fmod ( const MillerIndex & a,
const CScalar & b )

◆ fmod() [2/36]

MillerIndex fmod ( const MillerIndex & a,
const MillerIndex & b )

◆ fmod() [3/36]

Quaternion fmod ( const Quaternion & a,
const CScalar & b )

◆ fmod() [4/36]

Quaternion fmod ( const Quaternion & a,
const Quaternion & b )

◆ fmod() [5/36]

R2 fmod ( const R2 & a,
const CScalar & b )

◆ fmod() [6/36]

R2 fmod ( const R2 & a,
const R2 & b )

◆ fmod() [7/36]

R3 fmod ( const R3 & a,
const CScalar & b )

◆ fmod() [8/36]

R3 fmod ( const R3 & a,
const R3 & b )

◆ fmod() [9/36]

R4 fmod ( const R4 & a,
const CScalar & b )

◆ fmod() [10/36]

R4 fmod ( const R4 & a,
const R4 & b )

◆ fmod() [11/36]

Rot fmod ( const Rot & a,
const CScalar & b )

◆ fmod() [12/36]

Rot fmod ( const Rot & a,
const Rot & b )

◆ fmod() [13/36]

Scalar fmod ( const Scalar & a,
const CScalar & b )

◆ fmod() [14/36]

Scalar fmod ( const Scalar & a,
const Scalar & b )

◆ fmod() [15/36]

SFFR4 fmod ( const SFFR4 & a,
const CScalar & b )

◆ fmod() [16/36]

SFFR4 fmod ( const SFFR4 & a,
const SFFR4 & b )

◆ fmod() [17/36]

SFR3 fmod ( const SFR3 & a,
const CScalar & b )

◆ fmod() [18/36]

SFR3 fmod ( const SFR3 & a,
const SFR3 & b )

◆ fmod() [19/36]

SR2 fmod ( const SR2 & a,
const CScalar & b )

◆ fmod() [20/36]

SR2 fmod ( const SR2 & a,
const SR2 & b )

◆ fmod() [21/36]

SSR4 fmod ( const SSR4 & a,
const CScalar & b )

◆ fmod() [22/36]

SSR4 fmod ( const SSR4 & a,
const SSR4 & b )

◆ fmod() [23/36]

SWR4 fmod ( const SWR4 & a,
const CScalar & b )

◆ fmod() [24/36]

SWR4 fmod ( const SWR4 & a,
const SWR4 & b )

◆ fmod() [25/36]

Tensor fmod ( const Tensor & a,
const CScalar & b )

◆ fmod() [26/36]

Tensor fmod ( const Tensor & a,
const Tensor & b )

◆ fmod() [27/36]

Vec fmod ( const Vec & a,
const CScalar & b )

◆ fmod() [28/36]

Vec fmod ( const Vec & a,
const Vec & b )

◆ fmod() [29/36]

WFFR4 fmod ( const WFFR4 & a,
const CScalar & b )

◆ fmod() [30/36]

WFFR4 fmod ( const WFFR4 & a,
const WFFR4 & b )

◆ fmod() [31/36]

WR2 fmod ( const WR2 & a,
const CScalar & b )

◆ fmod() [32/36]

WR2 fmod ( const WR2 & a,
const WR2 & b )

◆ fmod() [33/36]

WSR4 fmod ( const WSR4 & a,
const CScalar & b )

◆ fmod() [34/36]

WSR4 fmod ( const WSR4 & a,
const WSR4 & b )

◆ fmod() [35/36]

WWR4 fmod ( const WWR4 & a,
const CScalar & b )

◆ fmod() [36/36]

WWR4 fmod ( const WWR4 & a,
const WWR4 & b )

◆ force_link_runtime()

void force_link_runtime ( )

Force linking of all runtime components.

This is a convenient function to call in the main executable to ensure that all runtime components are linked in. It simply calls all the force link functions defined above.

◆ from_assembly()

template<std::size_t N>
Tensor from_assembly ( const Tensor & from,
const std::array< TensorShape, N > & intmd_shapes,
const std::array< TensorShape, N > & base_shapes )

Convert a tensor from the assembly format to the normal format.

◆ full_to_mandel()

Tensor full_to_mandel ( const Tensor & full,
Size dim = 0 )

Convert a Tensor from full notation to Mandel notation.

The tensor in full notation full can have arbitrary batch shape. The optional argument dim denotes the base dimension starting from which the conversion should take place.

For example, a full tensor has shape (2, 3, 1, 5; 2, 9, 3, 3, 2, 3) where the semicolon separates batch and base shapes. The symmetric axes have base dim 2 and 3. After converting to Mandel notation, the resulting tensor will have shape (2, 3, 1, 5; 2, 9, 6, 2, 3). Note how the shape of the symmetric dimensions (3, 3) becomes (6). In this example, the base dim (the second argument to this function) should be 2.

Parameters
fullThe input tensor in full notation
dimThe base dimension where the symmetric axes start
Returns
Tensor The resulting tensor using Mandel notation to represent the symmetric axes.

◆ full_to_skew()

Tensor full_to_skew ( const Tensor & full,
Size dim = 0 )

Convert a Tensor from full notation to skew vector notation.

The tensor in full notation full can have arbitrary batch shape. The optional argument dim denotes the base dimension starting from which the conversion should take place.

For example, a full tensor has shape (2, 3, 1, 5; 2, 9, 3, 3, 2, 3) where the semicolon separates batch and base shapes. The symmetric axes have base dim 2 and 3. After converting to skew notation, the resulting tensor will have shape (2, 3, 1, 5; 2, 9, 3, 2, 3). Note how the shape of the symmetric dimensions (3, 3) becomes (3). In this example, the base dim (the second argument to this function) should be 2.

Parameters
fullThe input tensor in full notation
dimThe base dimension where the symmetric axes start
Returns
Tensor The resulting tensor using skew notation to represent the skew-symmetric axes.

◆ fullify()

template<std::size_t N>
Tensor fullify ( const Tensor & t,
Size iid,
std::array< TensorShape, N > iiss )

Convert the derivative with broadcasting intrinsic intermediate dimensions into a Tensor with full intrinsic intermediate dimensions. If this derivative is already full, simply returns the underlying tensor.

Template Parameters
NThe order of the derivative plus one
Parameters
tThe input derivative tensor
iidThe number of intrinsic intermediate dimensions of the derivative
iissThe intrinsic intermediate shapes of the variable and arguments

◆ gcd() [1/18]

MillerIndex gcd ( const MillerIndex & a,
const MillerIndex & b )

◆ gcd() [2/18]

Quaternion gcd ( const Quaternion & a,
const Quaternion & b )

◆ gcd() [3/18]

R2 gcd ( const R2 & a,
const R2 & b )

◆ gcd() [4/18]

R3 gcd ( const R3 & a,
const R3 & b )

◆ gcd() [5/18]

R4 gcd ( const R4 & a,
const R4 & b )

◆ gcd() [6/18]

Rot gcd ( const Rot & a,
const Rot & b )

◆ gcd() [7/18]

Scalar gcd ( const Scalar & a,
const Scalar & b )

◆ gcd() [8/18]

SFFR4 gcd ( const SFFR4 & a,
const SFFR4 & b )

◆ gcd() [9/18]

SFR3 gcd ( const SFR3 & a,
const SFR3 & b )

◆ gcd() [10/18]

SR2 gcd ( const SR2 & a,
const SR2 & b )

◆ gcd() [11/18]

SSR4 gcd ( const SSR4 & a,
const SSR4 & b )

◆ gcd() [12/18]

SWR4 gcd ( const SWR4 & a,
const SWR4 & b )

◆ gcd() [13/18]

Tensor gcd ( const Tensor & a,
const Tensor & b )

◆ gcd() [14/18]

Vec gcd ( const Vec & a,
const Vec & b )

◆ gcd() [15/18]

WFFR4 gcd ( const WFFR4 & a,
const WFFR4 & b )

◆ gcd() [16/18]

WR2 gcd ( const WR2 & a,
const WR2 & b )

◆ gcd() [17/18]

WSR4 gcd ( const WSR4 & a,
const WSR4 & b )

◆ gcd() [18/18]

WWR4 gcd ( const WWR4 & a,
const WWR4 & b )

◆ ge() [1/88]

MillerIndex ge ( const CScalar & a,
const MillerIndex & b )

◆ ge() [2/88]

Quaternion ge ( const CScalar & a,
const Quaternion & b )

◆ ge() [3/88]

R2 ge ( const CScalar & a,
const R2 & b )

◆ ge() [4/88]

R3 ge ( const CScalar & a,
const R3 & b )

◆ ge() [5/88]

R4 ge ( const CScalar & a,
const R4 & b )

◆ ge() [6/88]

Rot ge ( const CScalar & a,
const Rot & b )

◆ ge() [7/88]

Scalar ge ( const CScalar & a,
const Scalar & b )

◆ ge() [8/88]

SFFR4 ge ( const CScalar & a,
const SFFR4 & b )

◆ ge() [9/88]

SFR3 ge ( const CScalar & a,
const SFR3 & b )

◆ ge() [10/88]

SR2 ge ( const CScalar & a,
const SR2 & b )

◆ ge() [11/88]

SSR4 ge ( const CScalar & a,
const SSR4 & b )

◆ ge() [12/88]

SWR4 ge ( const CScalar & a,
const SWR4 & b )

◆ ge() [13/88]

Tensor ge ( const CScalar & a,
const Tensor & b )

◆ ge() [14/88]

Vec ge ( const CScalar & a,
const Vec & b )

◆ ge() [15/88]

WFFR4 ge ( const CScalar & a,
const WFFR4 & b )

◆ ge() [16/88]

WR2 ge ( const CScalar & a,
const WR2 & b )

◆ ge() [17/88]

WSR4 ge ( const CScalar & a,
const WSR4 & b )

◆ ge() [18/88]

WWR4 ge ( const CScalar & a,
const WWR4 & b )

◆ ge() [19/88]

MillerIndex ge ( const MillerIndex & a,
const CScalar & b )

◆ ge() [20/88]

MillerIndex ge ( const MillerIndex & a,
const MillerIndex & b )

◆ ge() [21/88]

MillerIndex ge ( const MillerIndex & a,
const Scalar & b )

◆ ge() [22/88]

Quaternion ge ( const Quaternion & a,
const CScalar & b )

◆ ge() [23/88]

Quaternion ge ( const Quaternion & a,
const Quaternion & b )

◆ ge() [24/88]

Quaternion ge ( const Quaternion & a,
const Scalar & b )

◆ ge() [25/88]

R2 ge ( const R2 & a,
const CScalar & b )

◆ ge() [26/88]

R2 ge ( const R2 & a,
const R2 & b )

◆ ge() [27/88]

R2 ge ( const R2 & a,
const Scalar & b )

◆ ge() [28/88]

R3 ge ( const R3 & a,
const CScalar & b )

◆ ge() [29/88]

R3 ge ( const R3 & a,
const R3 & b )

◆ ge() [30/88]

R3 ge ( const R3 & a,
const Scalar & b )

◆ ge() [31/88]

R4 ge ( const R4 & a,
const CScalar & b )

◆ ge() [32/88]

R4 ge ( const R4 & a,
const R4 & b )

◆ ge() [33/88]

R4 ge ( const R4 & a,
const Scalar & b )

◆ ge() [34/88]

Rot ge ( const Rot & a,
const CScalar & b )

◆ ge() [35/88]

Rot ge ( const Rot & a,
const Rot & b )

◆ ge() [36/88]

Rot ge ( const Rot & a,
const Scalar & b )

◆ ge() [37/88]

Scalar ge ( const Scalar & a,
const CScalar & b )

◆ ge() [38/88]

MillerIndex ge ( const Scalar & a,
const MillerIndex & b )

◆ ge() [39/88]

Quaternion ge ( const Scalar & a,
const Quaternion & b )

◆ ge() [40/88]

R2 ge ( const Scalar & a,
const R2 & b )

◆ ge() [41/88]

R3 ge ( const Scalar & a,
const R3 & b )

◆ ge() [42/88]

R4 ge ( const Scalar & a,
const R4 & b )

◆ ge() [43/88]

Rot ge ( const Scalar & a,
const Rot & b )

◆ ge() [44/88]

Scalar ge ( const Scalar & a,
const Scalar & b )

◆ ge() [45/88]

SFFR4 ge ( const Scalar & a,
const SFFR4 & b )

◆ ge() [46/88]

SFR3 ge ( const Scalar & a,
const SFR3 & b )

◆ ge() [47/88]

SR2 ge ( const Scalar & a,
const SR2 & b )

◆ ge() [48/88]

SSR4 ge ( const Scalar & a,
const SSR4 & b )

◆ ge() [49/88]

SWR4 ge ( const Scalar & a,
const SWR4 & b )

◆ ge() [50/88]

Tensor ge ( const Scalar & a,
const Tensor & b )

◆ ge() [51/88]

Vec ge ( const Scalar & a,
const Vec & b )

◆ ge() [52/88]

WFFR4 ge ( const Scalar & a,
const WFFR4 & b )

◆ ge() [53/88]

WR2 ge ( const Scalar & a,
const WR2 & b )

◆ ge() [54/88]

WSR4 ge ( const Scalar & a,
const WSR4 & b )

◆ ge() [55/88]

WWR4 ge ( const Scalar & a,
const WWR4 & b )

◆ ge() [56/88]

SFFR4 ge ( const SFFR4 & a,
const CScalar & b )

◆ ge() [57/88]

SFFR4 ge ( const SFFR4 & a,
const Scalar & b )

◆ ge() [58/88]

SFFR4 ge ( const SFFR4 & a,
const SFFR4 & b )

◆ ge() [59/88]

SFR3 ge ( const SFR3 & a,
const CScalar & b )

◆ ge() [60/88]

SFR3 ge ( const SFR3 & a,
const Scalar & b )

◆ ge() [61/88]

SFR3 ge ( const SFR3 & a,
const SFR3 & b )

◆ ge() [62/88]

SR2 ge ( const SR2 & a,
const CScalar & b )

◆ ge() [63/88]

SR2 ge ( const SR2 & a,
const Scalar & b )

◆ ge() [64/88]

SR2 ge ( const SR2 & a,
const SR2 & b )

◆ ge() [65/88]

SSR4 ge ( const SSR4 & a,
const CScalar & b )

◆ ge() [66/88]

SSR4 ge ( const SSR4 & a,
const Scalar & b )

◆ ge() [67/88]

SSR4 ge ( const SSR4 & a,
const SSR4 & b )

◆ ge() [68/88]

SWR4 ge ( const SWR4 & a,
const CScalar & b )

◆ ge() [69/88]

SWR4 ge ( const SWR4 & a,
const Scalar & b )

◆ ge() [70/88]

SWR4 ge ( const SWR4 & a,
const SWR4 & b )

◆ ge() [71/88]

Tensor ge ( const Tensor & a,
const CScalar & b )

◆ ge() [72/88]

Tensor ge ( const Tensor & a,
const Scalar & b )

◆ ge() [73/88]

Tensor ge ( const Tensor & a,
const Tensor & b )

◆ ge() [74/88]

Vec ge ( const Vec & a,
const CScalar & b )

◆ ge() [75/88]

Vec ge ( const Vec & a,
const Scalar & b )

◆ ge() [76/88]

Vec ge ( const Vec & a,
const Vec & b )

◆ ge() [77/88]

WFFR4 ge ( const WFFR4 & a,
const CScalar & b )

◆ ge() [78/88]

WFFR4 ge ( const WFFR4 & a,
const Scalar & b )

◆ ge() [79/88]

WFFR4 ge ( const WFFR4 & a,
const WFFR4 & b )

◆ ge() [80/88]

WR2 ge ( const WR2 & a,
const CScalar & b )

◆ ge() [81/88]

WR2 ge ( const WR2 & a,
const Scalar & b )

◆ ge() [82/88]

WR2 ge ( const WR2 & a,
const WR2 & b )

◆ ge() [83/88]

WSR4 ge ( const WSR4 & a,
const CScalar & b )

◆ ge() [84/88]

WSR4 ge ( const WSR4 & a,
const Scalar & b )

◆ ge() [85/88]

WSR4 ge ( const WSR4 & a,
const WSR4 & b )

◆ ge() [86/88]

WWR4 ge ( const WWR4 & a,
const CScalar & b )

◆ ge() [87/88]

WWR4 ge ( const WWR4 & a,
const Scalar & b )

◆ ge() [88/88]

WWR4 ge ( const WWR4 & a,
const WWR4 & b )

◆ get_default_dtype()

Dtype get_default_dtype ( )

Get default dtype.

◆ get_default_integer_dtype()

Dtype get_default_integer_dtype ( )

Get default integer dtype.

◆ gt() [1/88]

MillerIndex gt ( const CScalar & a,
const MillerIndex & b )

◆ gt() [2/88]

Quaternion gt ( const CScalar & a,
const Quaternion & b )

◆ gt() [3/88]

R2 gt ( const CScalar & a,
const R2 & b )

◆ gt() [4/88]

R3 gt ( const CScalar & a,
const R3 & b )

◆ gt() [5/88]

R4 gt ( const CScalar & a,
const R4 & b )

◆ gt() [6/88]

Rot gt ( const CScalar & a,
const Rot & b )

◆ gt() [7/88]

Scalar gt ( const CScalar & a,
const Scalar & b )

◆ gt() [8/88]

SFFR4 gt ( const CScalar & a,
const SFFR4 & b )

◆ gt() [9/88]

SFR3 gt ( const CScalar & a,
const SFR3 & b )

◆ gt() [10/88]

SR2 gt ( const CScalar & a,
const SR2 & b )

◆ gt() [11/88]

SSR4 gt ( const CScalar & a,
const SSR4 & b )

◆ gt() [12/88]

SWR4 gt ( const CScalar & a,
const SWR4 & b )

◆ gt() [13/88]

Tensor gt ( const CScalar & a,
const Tensor & b )

◆ gt() [14/88]

Vec gt ( const CScalar & a,
const Vec & b )

◆ gt() [15/88]

WFFR4 gt ( const CScalar & a,
const WFFR4 & b )

◆ gt() [16/88]

WR2 gt ( const CScalar & a,
const WR2 & b )

◆ gt() [17/88]

WSR4 gt ( const CScalar & a,
const WSR4 & b )

◆ gt() [18/88]

WWR4 gt ( const CScalar & a,
const WWR4 & b )

◆ gt() [19/88]

MillerIndex gt ( const MillerIndex & a,
const CScalar & b )

◆ gt() [20/88]

MillerIndex gt ( const MillerIndex & a,
const MillerIndex & b )

◆ gt() [21/88]

MillerIndex gt ( const MillerIndex & a,
const Scalar & b )

◆ gt() [22/88]

Quaternion gt ( const Quaternion & a,
const CScalar & b )

◆ gt() [23/88]

Quaternion gt ( const Quaternion & a,
const Quaternion & b )

◆ gt() [24/88]

Quaternion gt ( const Quaternion & a,
const Scalar & b )

◆ gt() [25/88]

R2 gt ( const R2 & a,
const CScalar & b )

◆ gt() [26/88]

R2 gt ( const R2 & a,
const R2 & b )

◆ gt() [27/88]

R2 gt ( const R2 & a,
const Scalar & b )

◆ gt() [28/88]

R3 gt ( const R3 & a,
const CScalar & b )

◆ gt() [29/88]

R3 gt ( const R3 & a,
const R3 & b )

◆ gt() [30/88]

R3 gt ( const R3 & a,
const Scalar & b )

◆ gt() [31/88]

R4 gt ( const R4 & a,
const CScalar & b )

◆ gt() [32/88]

R4 gt ( const R4 & a,
const R4 & b )

◆ gt() [33/88]

R4 gt ( const R4 & a,
const Scalar & b )

◆ gt() [34/88]

Rot gt ( const Rot & a,
const CScalar & b )

◆ gt() [35/88]

Rot gt ( const Rot & a,
const Rot & b )

◆ gt() [36/88]

Rot gt ( const Rot & a,
const Scalar & b )

◆ gt() [37/88]

Scalar gt ( const Scalar & a,
const CScalar & b )

◆ gt() [38/88]

MillerIndex gt ( const Scalar & a,
const MillerIndex & b )

◆ gt() [39/88]

Quaternion gt ( const Scalar & a,
const Quaternion & b )

◆ gt() [40/88]

R2 gt ( const Scalar & a,
const R2 & b )

◆ gt() [41/88]

R3 gt ( const Scalar & a,
const R3 & b )

◆ gt() [42/88]

R4 gt ( const Scalar & a,
const R4 & b )

◆ gt() [43/88]

Rot gt ( const Scalar & a,
const Rot & b )

◆ gt() [44/88]

Scalar gt ( const Scalar & a,
const Scalar & b )

◆ gt() [45/88]

SFFR4 gt ( const Scalar & a,
const SFFR4 & b )

◆ gt() [46/88]

SFR3 gt ( const Scalar & a,
const SFR3 & b )

◆ gt() [47/88]

SR2 gt ( const Scalar & a,
const SR2 & b )

◆ gt() [48/88]

SSR4 gt ( const Scalar & a,
const SSR4 & b )

◆ gt() [49/88]

SWR4 gt ( const Scalar & a,
const SWR4 & b )

◆ gt() [50/88]

Tensor gt ( const Scalar & a,
const Tensor & b )

◆ gt() [51/88]

Vec gt ( const Scalar & a,
const Vec & b )

◆ gt() [52/88]

WFFR4 gt ( const Scalar & a,
const WFFR4 & b )

◆ gt() [53/88]

WR2 gt ( const Scalar & a,
const WR2 & b )

◆ gt() [54/88]

WSR4 gt ( const Scalar & a,
const WSR4 & b )

◆ gt() [55/88]

WWR4 gt ( const Scalar & a,
const WWR4 & b )

◆ gt() [56/88]

SFFR4 gt ( const SFFR4 & a,
const CScalar & b )

◆ gt() [57/88]

SFFR4 gt ( const SFFR4 & a,
const Scalar & b )

◆ gt() [58/88]

SFFR4 gt ( const SFFR4 & a,
const SFFR4 & b )

◆ gt() [59/88]

SFR3 gt ( const SFR3 & a,
const CScalar & b )

◆ gt() [60/88]

SFR3 gt ( const SFR3 & a,
const Scalar & b )

◆ gt() [61/88]

SFR3 gt ( const SFR3 & a,
const SFR3 & b )

◆ gt() [62/88]

SR2 gt ( const SR2 & a,
const CScalar & b )

◆ gt() [63/88]

SR2 gt ( const SR2 & a,
const Scalar & b )

◆ gt() [64/88]

SR2 gt ( const SR2 & a,
const SR2 & b )

◆ gt() [65/88]

SSR4 gt ( const SSR4 & a,
const CScalar & b )

◆ gt() [66/88]

SSR4 gt ( const SSR4 & a,
const Scalar & b )

◆ gt() [67/88]

SSR4 gt ( const SSR4 & a,
const SSR4 & b )

◆ gt() [68/88]

SWR4 gt ( const SWR4 & a,
const CScalar & b )

◆ gt() [69/88]

SWR4 gt ( const SWR4 & a,
const Scalar & b )

◆ gt() [70/88]

SWR4 gt ( const SWR4 & a,
const SWR4 & b )

◆ gt() [71/88]

Tensor gt ( const Tensor & a,
const CScalar & b )

◆ gt() [72/88]

Tensor gt ( const Tensor & a,
const Scalar & b )

◆ gt() [73/88]

Tensor gt ( const Tensor & a,
const Tensor & b )

◆ gt() [74/88]

Vec gt ( const Vec & a,
const CScalar & b )

◆ gt() [75/88]

Vec gt ( const Vec & a,
const Scalar & b )

◆ gt() [76/88]

Vec gt ( const Vec & a,
const Vec & b )

◆ gt() [77/88]

WFFR4 gt ( const WFFR4 & a,
const CScalar & b )

◆ gt() [78/88]

WFFR4 gt ( const WFFR4 & a,
const Scalar & b )

◆ gt() [79/88]

WFFR4 gt ( const WFFR4 & a,
const WFFR4 & b )

◆ gt() [80/88]

WR2 gt ( const WR2 & a,
const CScalar & b )

◆ gt() [81/88]

WR2 gt ( const WR2 & a,
const Scalar & b )

◆ gt() [82/88]

WR2 gt ( const WR2 & a,
const WR2 & b )

◆ gt() [83/88]

WSR4 gt ( const WSR4 & a,
const CScalar & b )

◆ gt() [84/88]

WSR4 gt ( const WSR4 & a,
const Scalar & b )

◆ gt() [85/88]

WSR4 gt ( const WSR4 & a,
const WSR4 & b )

◆ gt() [86/88]

WWR4 gt ( const WWR4 & a,
const CScalar & b )

◆ gt() [87/88]

WWR4 gt ( const WWR4 & a,
const Scalar & b )

◆ gt() [88/88]

WWR4 gt ( const WWR4 & a,
const WWR4 & b )

◆ heaviside() [1/18]

MillerIndex heaviside ( const MillerIndex & a)

◆ heaviside() [2/18]

Quaternion heaviside ( const Quaternion & a)

◆ heaviside() [3/18]

R2 heaviside ( const R2 & a)

◆ heaviside() [4/18]

R3 heaviside ( const R3 & a)

◆ heaviside() [5/18]

R4 heaviside ( const R4 & a)

◆ heaviside() [6/18]

Rot heaviside ( const Rot & a)

◆ heaviside() [7/18]

Scalar heaviside ( const Scalar & a)

◆ heaviside() [8/18]

SFFR4 heaviside ( const SFFR4 & a)

◆ heaviside() [9/18]

SFR3 heaviside ( const SFR3 & a)

◆ heaviside() [10/18]

SR2 heaviside ( const SR2 & a)

◆ heaviside() [11/18]

SSR4 heaviside ( const SSR4 & a)

◆ heaviside() [12/18]

SWR4 heaviside ( const SWR4 & a)

◆ heaviside() [13/18]

Tensor heaviside ( const Tensor & a)

◆ heaviside() [14/18]

Vec heaviside ( const Vec & a)

◆ heaviside() [15/18]

WFFR4 heaviside ( const WFFR4 & a)

◆ heaviside() [16/18]

WR2 heaviside ( const WR2 & a)

◆ heaviside() [17/18]

WSR4 heaviside ( const WSR4 & a)

◆ heaviside() [18/18]

WWR4 heaviside ( const WWR4 & a)

◆ identity_transform()

R2 identity_transform ( const TensorOptions & options = default_tensor_options())

The identity transformation, i.e.e the Rank2 identity tensor.

◆ imap() [1/6]

template<>
DTensor< SSR4, SSR4, typename imap_t< SSR4 >::type > imap ( const TensorOptions & options)
inline

◆ imap() [2/6]

template<>
DTensor< SR2, SR2, typename imap_t< SR2 >::type > imap ( const TensorOptions & options)
inline

◆ imap() [3/6]

template<>
DTensor< R2, R2, typename imap_t< R2 >::type > imap ( const TensorOptions & options)
inline

◆ imap() [4/6]

template<>
DTensor< Vec, Vec, typename imap_t< Vec >::type > imap ( const TensorOptions & options)
inline

◆ imap() [5/6]

template<>
DTensor< Scalar, Scalar, typename imap_t< Scalar >::type > imap ( const TensorOptions & options)
inline

◆ imap() [6/6]

template<typename T>
DTensor< T, T, typename imap_t< T >::type > imap ( const TensorOptions & options = default_tensor_options())

Identity map.

◆ imap_v()

template<typename T>
imap_t< T >::type imap_v ( const TensorOptions & options = default_tensor_options())

Get the identity map interpreted as the concrete primitive tensor type.

◆ improper_rotation_transform()

R2 improper_rotation_transform ( const Rot & rot)

An improper rotation (rotation + reflection), here provided by a rot object giving the rotation and reflection axis.

◆ inner() [1/2]

Scalar inner ( const SparseTensorList & ,
const SparseTensorList &  )

Inner product.

◆ inner() [2/2]

Scalar inner ( const Tensor & a,
const Tensor & b )

Inner product.

◆ intmd_argmax() [1/18]

MillerIndex intmd_argmax ( const MillerIndex & a,
Size dim )

◆ intmd_argmax() [2/18]

Quaternion intmd_argmax ( const Quaternion & a,
Size dim )

◆ intmd_argmax() [3/18]

R2 intmd_argmax ( const R2 & a,
Size dim )

◆ intmd_argmax() [4/18]

R3 intmd_argmax ( const R3 & a,
Size dim )

◆ intmd_argmax() [5/18]

R4 intmd_argmax ( const R4 & a,
Size dim )

◆ intmd_argmax() [6/18]

Rot intmd_argmax ( const Rot & a,
Size dim )

◆ intmd_argmax() [7/18]

Scalar intmd_argmax ( const Scalar & a,
Size dim )

◆ intmd_argmax() [8/18]

SFFR4 intmd_argmax ( const SFFR4 & a,
Size dim )

◆ intmd_argmax() [9/18]

SFR3 intmd_argmax ( const SFR3 & a,
Size dim )

◆ intmd_argmax() [10/18]

SR2 intmd_argmax ( const SR2 & a,
Size dim )

◆ intmd_argmax() [11/18]

SSR4 intmd_argmax ( const SSR4 & a,
Size dim )

◆ intmd_argmax() [12/18]

SWR4 intmd_argmax ( const SWR4 & a,
Size dim )

◆ intmd_argmax() [13/18]

Tensor intmd_argmax ( const Tensor & a,
Size dim )

◆ intmd_argmax() [14/18]

Vec intmd_argmax ( const Vec & a,
Size dim )

◆ intmd_argmax() [15/18]

WFFR4 intmd_argmax ( const WFFR4 & a,
Size dim )

◆ intmd_argmax() [16/18]

WR2 intmd_argmax ( const WR2 & a,
Size dim )

◆ intmd_argmax() [17/18]

WSR4 intmd_argmax ( const WSR4 & a,
Size dim )

◆ intmd_argmax() [18/18]

WWR4 intmd_argmax ( const WWR4 & a,
Size dim )

◆ intmd_argmin() [1/18]

MillerIndex intmd_argmin ( const MillerIndex & a,
Size dim )

◆ intmd_argmin() [2/18]

Quaternion intmd_argmin ( const Quaternion & a,
Size dim )

◆ intmd_argmin() [3/18]

R2 intmd_argmin ( const R2 & a,
Size dim )

◆ intmd_argmin() [4/18]

R3 intmd_argmin ( const R3 & a,
Size dim )

◆ intmd_argmin() [5/18]

R4 intmd_argmin ( const R4 & a,
Size dim )

◆ intmd_argmin() [6/18]

Rot intmd_argmin ( const Rot & a,
Size dim )

◆ intmd_argmin() [7/18]

Scalar intmd_argmin ( const Scalar & a,
Size dim )

◆ intmd_argmin() [8/18]

SFFR4 intmd_argmin ( const SFFR4 & a,
Size dim )

◆ intmd_argmin() [9/18]

SFR3 intmd_argmin ( const SFR3 & a,
Size dim )

◆ intmd_argmin() [10/18]

SR2 intmd_argmin ( const SR2 & a,
Size dim )

◆ intmd_argmin() [11/18]

SSR4 intmd_argmin ( const SSR4 & a,
Size dim )

◆ intmd_argmin() [12/18]

SWR4 intmd_argmin ( const SWR4 & a,
Size dim )

◆ intmd_argmin() [13/18]

Tensor intmd_argmin ( const Tensor & a,
Size dim )

◆ intmd_argmin() [14/18]

Vec intmd_argmin ( const Vec & a,
Size dim )

◆ intmd_argmin() [15/18]

WFFR4 intmd_argmin ( const WFFR4 & a,
Size dim )

◆ intmd_argmin() [16/18]

WR2 intmd_argmin ( const WR2 & a,
Size dim )

◆ intmd_argmin() [17/18]

WSR4 intmd_argmin ( const WSR4 & a,
Size dim )

◆ intmd_argmin() [18/18]

WWR4 intmd_argmin ( const WWR4 & a,
Size dim )

◆ intmd_cat() [1/36]

MillerIndex intmd_cat ( const std::initializer_list< MillerIndex > & tensors,
Size d = 0 )

◆ intmd_cat() [2/36]

Quaternion intmd_cat ( const std::initializer_list< Quaternion > & tensors,
Size d = 0 )

◆ intmd_cat() [3/36]

R2 intmd_cat ( const std::initializer_list< R2 > & tensors,
Size d = 0 )

◆ intmd_cat() [4/36]

R3 intmd_cat ( const std::initializer_list< R3 > & tensors,
Size d = 0 )

◆ intmd_cat() [5/36]

R4 intmd_cat ( const std::initializer_list< R4 > & tensors,
Size d = 0 )

◆ intmd_cat() [6/36]

Rot intmd_cat ( const std::initializer_list< Rot > & tensors,
Size d = 0 )

◆ intmd_cat() [7/36]

Scalar intmd_cat ( const std::initializer_list< Scalar > & tensors,
Size d = 0 )

◆ intmd_cat() [8/36]

SFFR4 intmd_cat ( const std::initializer_list< SFFR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [9/36]

SFR3 intmd_cat ( const std::initializer_list< SFR3 > & tensors,
Size d = 0 )

◆ intmd_cat() [10/36]

SR2 intmd_cat ( const std::initializer_list< SR2 > & tensors,
Size d = 0 )

◆ intmd_cat() [11/36]

SSR4 intmd_cat ( const std::initializer_list< SSR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [12/36]

SWR4 intmd_cat ( const std::initializer_list< SWR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [13/36]

Tensor intmd_cat ( const std::initializer_list< Tensor > & tensors,
Size d = 0 )

◆ intmd_cat() [14/36]

Vec intmd_cat ( const std::initializer_list< Vec > & tensors,
Size d = 0 )

◆ intmd_cat() [15/36]

WFFR4 intmd_cat ( const std::initializer_list< WFFR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [16/36]

WR2 intmd_cat ( const std::initializer_list< WR2 > & tensors,
Size d = 0 )

◆ intmd_cat() [17/36]

WSR4 intmd_cat ( const std::initializer_list< WSR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [18/36]

WWR4 intmd_cat ( const std::initializer_list< WWR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [19/36]

MillerIndex intmd_cat ( const std::vector< MillerIndex > & tensors,
Size d = 0 )

◆ intmd_cat() [20/36]

Quaternion intmd_cat ( const std::vector< Quaternion > & tensors,
Size d = 0 )

◆ intmd_cat() [21/36]

R2 intmd_cat ( const std::vector< R2 > & tensors,
Size d = 0 )

◆ intmd_cat() [22/36]

R3 intmd_cat ( const std::vector< R3 > & tensors,
Size d = 0 )

◆ intmd_cat() [23/36]

R4 intmd_cat ( const std::vector< R4 > & tensors,
Size d = 0 )

◆ intmd_cat() [24/36]

Rot intmd_cat ( const std::vector< Rot > & tensors,
Size d = 0 )

◆ intmd_cat() [25/36]

Scalar intmd_cat ( const std::vector< Scalar > & tensors,
Size d = 0 )

◆ intmd_cat() [26/36]

SFFR4 intmd_cat ( const std::vector< SFFR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [27/36]

SFR3 intmd_cat ( const std::vector< SFR3 > & tensors,
Size d = 0 )

◆ intmd_cat() [28/36]

SR2 intmd_cat ( const std::vector< SR2 > & tensors,
Size d = 0 )

◆ intmd_cat() [29/36]

SSR4 intmd_cat ( const std::vector< SSR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [30/36]

SWR4 intmd_cat ( const std::vector< SWR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [31/36]

Tensor intmd_cat ( const std::vector< Tensor > & tensors,
Size d = 0 )

◆ intmd_cat() [32/36]

Vec intmd_cat ( const std::vector< Vec > & tensors,
Size d = 0 )

◆ intmd_cat() [33/36]

WFFR4 intmd_cat ( const std::vector< WFFR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [34/36]

WR2 intmd_cat ( const std::vector< WR2 > & tensors,
Size d = 0 )

◆ intmd_cat() [35/36]

WSR4 intmd_cat ( const std::vector< WSR4 > & tensors,
Size d = 0 )

◆ intmd_cat() [36/36]

WWR4 intmd_cat ( const std::vector< WWR4 > & tensors,
Size d = 0 )

◆ intmd_diagonalize() [1/18]

MillerIndex intmd_diagonalize ( const MillerIndex & a,
Size d = -1 )

◆ intmd_diagonalize() [2/18]

Quaternion intmd_diagonalize ( const Quaternion & a,
Size d = -1 )

◆ intmd_diagonalize() [3/18]

R2 intmd_diagonalize ( const R2 & a,
Size d = -1 )

◆ intmd_diagonalize() [4/18]

R3 intmd_diagonalize ( const R3 & a,
Size d = -1 )

◆ intmd_diagonalize() [5/18]

R4 intmd_diagonalize ( const R4 & a,
Size d = -1 )

◆ intmd_diagonalize() [6/18]

Rot intmd_diagonalize ( const Rot & a,
Size d = -1 )

◆ intmd_diagonalize() [7/18]

Scalar intmd_diagonalize ( const Scalar & a,
Size d = -1 )

◆ intmd_diagonalize() [8/18]

SFFR4 intmd_diagonalize ( const SFFR4 & a,
Size d = -1 )

◆ intmd_diagonalize() [9/18]

SFR3 intmd_diagonalize ( const SFR3 & a,
Size d = -1 )

◆ intmd_diagonalize() [10/18]

SR2 intmd_diagonalize ( const SR2 & a,
Size d = -1 )

◆ intmd_diagonalize() [11/18]

SSR4 intmd_diagonalize ( const SSR4 & a,
Size d = -1 )

◆ intmd_diagonalize() [12/18]

SWR4 intmd_diagonalize ( const SWR4 & a,
Size d = -1 )

◆ intmd_diagonalize() [13/18]

Tensor intmd_diagonalize ( const Tensor & a,
Size d = -1 )

◆ intmd_diagonalize() [14/18]

Vec intmd_diagonalize ( const Vec & a,
Size d = -1 )

◆ intmd_diagonalize() [15/18]

WFFR4 intmd_diagonalize ( const WFFR4 & a,
Size d = -1 )

◆ intmd_diagonalize() [16/18]

WR2 intmd_diagonalize ( const WR2 & a,
Size d = -1 )

◆ intmd_diagonalize() [17/18]

WSR4 intmd_diagonalize ( const WSR4 & a,
Size d = -1 )

◆ intmd_diagonalize() [18/18]

WWR4 intmd_diagonalize ( const WWR4 & a,
Size d = -1 )

◆ intmd_diff() [1/18]

MillerIndex intmd_diff ( const MillerIndex & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [2/18]

Quaternion intmd_diff ( const Quaternion & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [3/18]

R2 intmd_diff ( const R2 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [4/18]

R3 intmd_diff ( const R3 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [5/18]

R4 intmd_diff ( const R4 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [6/18]

Rot intmd_diff ( const Rot & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [7/18]

Scalar intmd_diff ( const Scalar & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [8/18]

SFFR4 intmd_diff ( const SFFR4 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [9/18]

SFR3 intmd_diff ( const SFR3 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [10/18]

SR2 intmd_diff ( const SR2 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [11/18]

SSR4 intmd_diff ( const SSR4 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [12/18]

SWR4 intmd_diff ( const SWR4 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [13/18]

Tensor intmd_diff ( const Tensor & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [14/18]

Vec intmd_diff ( const Vec & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [15/18]

WFFR4 intmd_diff ( const WFFR4 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [16/18]

WR2 intmd_diff ( const WR2 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [17/18]

WSR4 intmd_diff ( const WSR4 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_diff() [18/18]

WWR4 intmd_diff ( const WWR4 & a,
Size n = 1,
Size dim = -1 )

◆ intmd_linspace() [1/18]

MillerIndex intmd_linspace ( const MillerIndex & start,
const MillerIndex & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [2/18]

Quaternion intmd_linspace ( const Quaternion & start,
const Quaternion & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [3/18]

R2 intmd_linspace ( const R2 & start,
const R2 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [4/18]

R3 intmd_linspace ( const R3 & start,
const R3 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [5/18]

R4 intmd_linspace ( const R4 & start,
const R4 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [6/18]

Rot intmd_linspace ( const Rot & start,
const Rot & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [7/18]

Scalar intmd_linspace ( const Scalar & start,
const Scalar & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [8/18]

SFFR4 intmd_linspace ( const SFFR4 & start,
const SFFR4 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [9/18]

SFR3 intmd_linspace ( const SFR3 & start,
const SFR3 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [10/18]

SR2 intmd_linspace ( const SR2 & start,
const SR2 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [11/18]

SSR4 intmd_linspace ( const SSR4 & start,
const SSR4 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [12/18]

SWR4 intmd_linspace ( const SWR4 & start,
const SWR4 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [13/18]

Tensor intmd_linspace ( const Tensor & start,
const Tensor & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [14/18]

Vec intmd_linspace ( const Vec & start,
const Vec & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [15/18]

WFFR4 intmd_linspace ( const WFFR4 & start,
const WFFR4 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [16/18]

WR2 intmd_linspace ( const WR2 & start,
const WR2 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [17/18]

WSR4 intmd_linspace ( const WSR4 & start,
const WSR4 & end,
Size nstep,
Size dim = 0 )

◆ intmd_linspace() [18/18]

WWR4 intmd_linspace ( const WWR4 & start,
const WWR4 & end,
Size nstep,
Size dim = 0 )

◆ intmd_logspace() [1/18]

MillerIndex intmd_logspace ( const MillerIndex & start,
const MillerIndex & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [2/18]

Quaternion intmd_logspace ( const Quaternion & start,
const Quaternion & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [3/18]

R2 intmd_logspace ( const R2 & start,
const R2 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [4/18]

R3 intmd_logspace ( const R3 & start,
const R3 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [5/18]

R4 intmd_logspace ( const R4 & start,
const R4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [6/18]

Rot intmd_logspace ( const Rot & start,
const Rot & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [7/18]

Scalar intmd_logspace ( const Scalar & start,
const Scalar & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [8/18]

SFFR4 intmd_logspace ( const SFFR4 & start,
const SFFR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [9/18]

SFR3 intmd_logspace ( const SFR3 & start,
const SFR3 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [10/18]

SR2 intmd_logspace ( const SR2 & start,
const SR2 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [11/18]

SSR4 intmd_logspace ( const SSR4 & start,
const SSR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [12/18]

SWR4 intmd_logspace ( const SWR4 & start,
const SWR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [13/18]

Tensor intmd_logspace ( const Tensor & start,
const Tensor & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [14/18]

Vec intmd_logspace ( const Vec & start,
const Vec & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [15/18]

WFFR4 intmd_logspace ( const WFFR4 & start,
const WFFR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [16/18]

WR2 intmd_logspace ( const WR2 & start,
const WR2 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [17/18]

WSR4 intmd_logspace ( const WSR4 & start,
const WSR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_logspace() [18/18]

WWR4 intmd_logspace ( const WWR4 & start,
const WWR4 & end,
Size nstep,
Size dim = 0,
const CScalar & base = 10.0 )

◆ intmd_max() [1/18]

MillerIndex intmd_max ( const MillerIndex & a,
Size d = 0 )

◆ intmd_max() [2/18]

Quaternion intmd_max ( const Quaternion & a,
Size d = 0 )

◆ intmd_max() [3/18]

R2 intmd_max ( const R2 & a,
Size d = 0 )

◆ intmd_max() [4/18]

R3 intmd_max ( const R3 & a,
Size d = 0 )

◆ intmd_max() [5/18]

R4 intmd_max ( const R4 & a,
Size d = 0 )

◆ intmd_max() [6/18]

Rot intmd_max ( const Rot & a,
Size d = 0 )

◆ intmd_max() [7/18]

Scalar intmd_max ( const Scalar & a,
Size d = 0 )

◆ intmd_max() [8/18]

SFFR4 intmd_max ( const SFFR4 & a,
Size d = 0 )

◆ intmd_max() [9/18]

SFR3 intmd_max ( const SFR3 & a,
Size d = 0 )

◆ intmd_max() [10/18]

SR2 intmd_max ( const SR2 & a,
Size d = 0 )

◆ intmd_max() [11/18]

SSR4 intmd_max ( const SSR4 & a,
Size d = 0 )

◆ intmd_max() [12/18]

SWR4 intmd_max ( const SWR4 & a,
Size d = 0 )

◆ intmd_max() [13/18]

Tensor intmd_max ( const Tensor & a,
Size d = 0 )

◆ intmd_max() [14/18]

Vec intmd_max ( const Vec & a,
Size d = 0 )

◆ intmd_max() [15/18]

WFFR4 intmd_max ( const WFFR4 & a,
Size d = 0 )

◆ intmd_max() [16/18]

WR2 intmd_max ( const WR2 & a,
Size d = 0 )

◆ intmd_max() [17/18]

WSR4 intmd_max ( const WSR4 & a,
Size d = 0 )

◆ intmd_max() [18/18]

WWR4 intmd_max ( const WWR4 & a,
Size d = 0 )

◆ intmd_mean() [1/18]

MillerIndex intmd_mean ( const MillerIndex & a,
Size d = 0 )

◆ intmd_mean() [2/18]

Quaternion intmd_mean ( const Quaternion & a,
Size d = 0 )

◆ intmd_mean() [3/18]

R2 intmd_mean ( const R2 & a,
Size d = 0 )

◆ intmd_mean() [4/18]

R3 intmd_mean ( const R3 & a,
Size d = 0 )

◆ intmd_mean() [5/18]

R4 intmd_mean ( const R4 & a,
Size d = 0 )

◆ intmd_mean() [6/18]

Rot intmd_mean ( const Rot & a,
Size d = 0 )

◆ intmd_mean() [7/18]

Scalar intmd_mean ( const Scalar & a,
Size d = 0 )

◆ intmd_mean() [8/18]

SFFR4 intmd_mean ( const SFFR4 & a,
Size d = 0 )

◆ intmd_mean() [9/18]

SFR3 intmd_mean ( const SFR3 & a,
Size d = 0 )

◆ intmd_mean() [10/18]

SR2 intmd_mean ( const SR2 & a,
Size d = 0 )

◆ intmd_mean() [11/18]

SSR4 intmd_mean ( const SSR4 & a,
Size d = 0 )

◆ intmd_mean() [12/18]

SWR4 intmd_mean ( const SWR4 & a,
Size d = 0 )

◆ intmd_mean() [13/18]

Tensor intmd_mean ( const Tensor & a,
Size d = 0 )

◆ intmd_mean() [14/18]

Vec intmd_mean ( const Vec & a,
Size d = 0 )

◆ intmd_mean() [15/18]

WFFR4 intmd_mean ( const WFFR4 & a,
Size d = 0 )

◆ intmd_mean() [16/18]

WR2 intmd_mean ( const WR2 & a,
Size d = 0 )

◆ intmd_mean() [17/18]

WSR4 intmd_mean ( const WSR4 & a,
Size d = 0 )

◆ intmd_mean() [18/18]

WWR4 intmd_mean ( const WWR4 & a,
Size d = 0 )

◆ intmd_min() [1/18]

MillerIndex intmd_min ( const MillerIndex & a,
Size d = 0 )

◆ intmd_min() [2/18]

Quaternion intmd_min ( const Quaternion & a,
Size d = 0 )

◆ intmd_min() [3/18]

R2 intmd_min ( const R2 & a,
Size d = 0 )

◆ intmd_min() [4/18]

R3 intmd_min ( const R3 & a,
Size d = 0 )

◆ intmd_min() [5/18]

R4 intmd_min ( const R4 & a,
Size d = 0 )

◆ intmd_min() [6/18]

Rot intmd_min ( const Rot & a,
Size d = 0 )

◆ intmd_min() [7/18]

Scalar intmd_min ( const Scalar & a,
Size d = 0 )

◆ intmd_min() [8/18]

SFFR4 intmd_min ( const SFFR4 & a,
Size d = 0 )

◆ intmd_min() [9/18]

SFR3 intmd_min ( const SFR3 & a,
Size d = 0 )

◆ intmd_min() [10/18]

SR2 intmd_min ( const SR2 & a,
Size d = 0 )

◆ intmd_min() [11/18]

SSR4 intmd_min ( const SSR4 & a,
Size d = 0 )

◆ intmd_min() [12/18]

SWR4 intmd_min ( const SWR4 & a,
Size d = 0 )

◆ intmd_min() [13/18]

Tensor intmd_min ( const Tensor & a,
Size d = 0 )

◆ intmd_min() [14/18]

Vec intmd_min ( const Vec & a,
Size d = 0 )

◆ intmd_min() [15/18]

WFFR4 intmd_min ( const WFFR4 & a,
Size d = 0 )

◆ intmd_min() [16/18]

WR2 intmd_min ( const WR2 & a,
Size d = 0 )

◆ intmd_min() [17/18]

WSR4 intmd_min ( const WSR4 & a,
Size d = 0 )

◆ intmd_min() [18/18]

WWR4 intmd_min ( const WWR4 & a,
Size d = 0 )

◆ intmd_stack() [1/36]

MillerIndex intmd_stack ( const std::initializer_list< MillerIndex > & tensors,
Size d = 0 )

◆ intmd_stack() [2/36]

Quaternion intmd_stack ( const std::initializer_list< Quaternion > & tensors,
Size d = 0 )

◆ intmd_stack() [3/36]

R2 intmd_stack ( const std::initializer_list< R2 > & tensors,
Size d = 0 )

◆ intmd_stack() [4/36]

R3 intmd_stack ( const std::initializer_list< R3 > & tensors,
Size d = 0 )

◆ intmd_stack() [5/36]

R4 intmd_stack ( const std::initializer_list< R4 > & tensors,
Size d = 0 )

◆ intmd_stack() [6/36]

Rot intmd_stack ( const std::initializer_list< Rot > & tensors,
Size d = 0 )

◆ intmd_stack() [7/36]

Scalar intmd_stack ( const std::initializer_list< Scalar > & tensors,
Size d = 0 )

◆ intmd_stack() [8/36]

SFFR4 intmd_stack ( const std::initializer_list< SFFR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [9/36]

SFR3 intmd_stack ( const std::initializer_list< SFR3 > & tensors,
Size d = 0 )

◆ intmd_stack() [10/36]

SR2 intmd_stack ( const std::initializer_list< SR2 > & tensors,
Size d = 0 )

◆ intmd_stack() [11/36]

SSR4 intmd_stack ( const std::initializer_list< SSR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [12/36]

SWR4 intmd_stack ( const std::initializer_list< SWR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [13/36]

Tensor intmd_stack ( const std::initializer_list< Tensor > & tensors,
Size d = 0 )

◆ intmd_stack() [14/36]

Vec intmd_stack ( const std::initializer_list< Vec > & tensors,
Size d = 0 )

◆ intmd_stack() [15/36]

WFFR4 intmd_stack ( const std::initializer_list< WFFR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [16/36]

WR2 intmd_stack ( const std::initializer_list< WR2 > & tensors,
Size d = 0 )

◆ intmd_stack() [17/36]

WSR4 intmd_stack ( const std::initializer_list< WSR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [18/36]

WWR4 intmd_stack ( const std::initializer_list< WWR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [19/36]

MillerIndex intmd_stack ( const std::vector< MillerIndex > & tensors,
Size d = 0 )

◆ intmd_stack() [20/36]

Quaternion intmd_stack ( const std::vector< Quaternion > & tensors,
Size d = 0 )

◆ intmd_stack() [21/36]

R2 intmd_stack ( const std::vector< R2 > & tensors,
Size d = 0 )

◆ intmd_stack() [22/36]

R3 intmd_stack ( const std::vector< R3 > & tensors,
Size d = 0 )

◆ intmd_stack() [23/36]

R4 intmd_stack ( const std::vector< R4 > & tensors,
Size d = 0 )

◆ intmd_stack() [24/36]

Rot intmd_stack ( const std::vector< Rot > & tensors,
Size d = 0 )

◆ intmd_stack() [25/36]

Scalar intmd_stack ( const std::vector< Scalar > & tensors,
Size d = 0 )

◆ intmd_stack() [26/36]

SFFR4 intmd_stack ( const std::vector< SFFR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [27/36]

SFR3 intmd_stack ( const std::vector< SFR3 > & tensors,
Size d = 0 )

◆ intmd_stack() [28/36]

SR2 intmd_stack ( const std::vector< SR2 > & tensors,
Size d = 0 )

◆ intmd_stack() [29/36]

SSR4 intmd_stack ( const std::vector< SSR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [30/36]

SWR4 intmd_stack ( const std::vector< SWR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [31/36]

Tensor intmd_stack ( const std::vector< Tensor > & tensors,
Size d = 0 )

◆ intmd_stack() [32/36]

Vec intmd_stack ( const std::vector< Vec > & tensors,
Size d = 0 )

◆ intmd_stack() [33/36]

WFFR4 intmd_stack ( const std::vector< WFFR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [34/36]

WR2 intmd_stack ( const std::vector< WR2 > & tensors,
Size d = 0 )

◆ intmd_stack() [35/36]

WSR4 intmd_stack ( const std::vector< WSR4 > & tensors,
Size d = 0 )

◆ intmd_stack() [36/36]

WWR4 intmd_stack ( const std::vector< WWR4 > & tensors,
Size d = 0 )

◆ intmd_sum() [1/18]

MillerIndex intmd_sum ( const MillerIndex & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [2/18]

Quaternion intmd_sum ( const Quaternion & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [3/18]

R2 intmd_sum ( const R2 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [4/18]

R3 intmd_sum ( const R3 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [5/18]

R4 intmd_sum ( const R4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [6/18]

Rot intmd_sum ( const Rot & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [7/18]

Scalar intmd_sum ( const Scalar & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [8/18]

SFFR4 intmd_sum ( const SFFR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [9/18]

SFR3 intmd_sum ( const SFR3 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [10/18]

SR2 intmd_sum ( const SR2 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [11/18]

SSR4 intmd_sum ( const SSR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [12/18]

SWR4 intmd_sum ( const SWR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [13/18]

Tensor intmd_sum ( const Tensor & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [14/18]

Vec intmd_sum ( const Vec & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [15/18]

WFFR4 intmd_sum ( const WFFR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [16/18]

WR2 intmd_sum ( const WR2 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [17/18]

WSR4 intmd_sum ( const WSR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum() [18/18]

WWR4 intmd_sum ( const WWR4 & a,
ArrayRef< Size > d = 0,
bool keepdim = false )

◆ intmd_sum_to_size() [1/18]

MillerIndex intmd_sum_to_size ( const MillerIndex & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [2/18]

Quaternion intmd_sum_to_size ( const Quaternion & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [3/18]

R2 intmd_sum_to_size ( const R2 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [4/18]

R3 intmd_sum_to_size ( const R3 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [5/18]

R4 intmd_sum_to_size ( const R4 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [6/18]

Rot intmd_sum_to_size ( const Rot & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [7/18]

Scalar intmd_sum_to_size ( const Scalar & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [8/18]

SFFR4 intmd_sum_to_size ( const SFFR4 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [9/18]

SFR3 intmd_sum_to_size ( const SFR3 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [10/18]

SR2 intmd_sum_to_size ( const SR2 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [11/18]

SSR4 intmd_sum_to_size ( const SSR4 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [12/18]

SWR4 intmd_sum_to_size ( const SWR4 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [13/18]

Tensor intmd_sum_to_size ( const Tensor & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [14/18]

Vec intmd_sum_to_size ( const Vec & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [15/18]

WFFR4 intmd_sum_to_size ( const WFFR4 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [16/18]

WR2 intmd_sum_to_size ( const WR2 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [17/18]

WSR4 intmd_sum_to_size ( const WSR4 & a,
TensorShapeRef shape )

◆ intmd_sum_to_size() [18/18]

WWR4 intmd_sum_to_size ( const WWR4 & a,
TensorShapeRef shape )

◆ inv() [1/6]

R2 inv ( const R2 & )

Inverse of a second order tensor

◆ inv() [2/6]

R4 inv ( const R4 & )

Inverse of a fourth order tensor, i.e., \(A^{-1}_{ijmn} A_{mnkl} = \delta_{il} \delta_{jk}\)

◆ inv() [3/6]

Rot inv ( const Rot & )

Inverse of a rotation (MRP).

◆ inv() [4/6]

SR2 inv ( const SR2 & )

◆ inv() [5/6]

SSR4 inv ( const SSR4 & )

◆ inv() [6/6]

Tensor inv ( const Tensor & )

Inverse of a second order or fourth order tensor.

◆ inversion_transform()

R2 inversion_transform ( const TensorOptions & options = default_tensor_options())

An inversion center.

◆ jacrev() [1/2]

std::vector< Tensor > jacrev ( const Tensor & y,
const std::vector< Tensor > & xs,
bool retain_graph = false,
bool create_graph = false,
bool allow_unused = false )

Use automatic differentiation (AD) to calculate the derivatives of a Tensor w.r.t. another Tensor.

Warning
Torch (and hence NEML2) AD wasn't designed to compute the full Jacobian from the very beginning. Using this method to calculate the full Jacobian is inefficient and is subjected to some restrictions on batch shapes.
Parameters
yThe Tensor to to be differentiated
xsThe arguments to take derivatives with respect to
retain_graphWhether to retain the computation graph (necessary if y has base storage size>1)
create_graphWhether to create the computation graph (necessary if you want to differentiate the returned Jacobian)
allow_unusedWhether to allow unused input argument x
Returns
Tensor \(\partial y/\partial p\)

◆ jacrev() [2/2]

Tensor jacrev ( const Tensor & y,
const Tensor & x,
bool retain_graph = false,
bool create_graph = false,
bool allow_unused = false )

Similar to the other jacrev, but for a single input.

◆ le() [1/88]

MillerIndex le ( const CScalar & a,
const MillerIndex & b )

◆ le() [2/88]

Quaternion le ( const CScalar & a,
const Quaternion & b )

◆ le() [3/88]

R2 le ( const CScalar & a,
const R2 & b )

◆ le() [4/88]

R3 le ( const CScalar & a,
const R3 & b )

◆ le() [5/88]

R4 le ( const CScalar & a,
const R4 & b )

◆ le() [6/88]

Rot le ( const CScalar & a,
const Rot & b )

◆ le() [7/88]

Scalar le ( const CScalar & a,
const Scalar & b )

◆ le() [8/88]

SFFR4 le ( const CScalar & a,
const SFFR4 & b )

◆ le() [9/88]

SFR3 le ( const CScalar & a,
const SFR3 & b )

◆ le() [10/88]

SR2 le ( const CScalar & a,
const SR2 & b )

◆ le() [11/88]

SSR4 le ( const CScalar & a,
const SSR4 & b )

◆ le() [12/88]

SWR4 le ( const CScalar & a,
const SWR4 & b )

◆ le() [13/88]

Tensor le ( const CScalar & a,
const Tensor & b )

◆ le() [14/88]

Vec le ( const CScalar & a,
const Vec & b )

◆ le() [15/88]

WFFR4 le ( const CScalar & a,
const WFFR4 & b )

◆ le() [16/88]

WR2 le ( const CScalar & a,
const WR2 & b )

◆ le() [17/88]

WSR4 le ( const CScalar & a,
const WSR4 & b )

◆ le() [18/88]

WWR4 le ( const CScalar & a,
const WWR4 & b )

◆ le() [19/88]

MillerIndex le ( const MillerIndex & a,
const CScalar & b )

◆ le() [20/88]

MillerIndex le ( const MillerIndex & a,
const MillerIndex & b )

◆ le() [21/88]

MillerIndex le ( const MillerIndex & a,
const Scalar & b )

◆ le() [22/88]

Quaternion le ( const Quaternion & a,
const CScalar & b )

◆ le() [23/88]

Quaternion le ( const Quaternion & a,
const Quaternion & b )

◆ le() [24/88]

Quaternion le ( const Quaternion & a,
const Scalar & b )

◆ le() [25/88]

R2 le ( const R2 & a,
const CScalar & b )

◆ le() [26/88]

R2 le ( const R2 & a,
const R2 & b )

◆ le() [27/88]

R2 le ( const R2 & a,
const Scalar & b )

◆ le() [28/88]

R3 le ( const R3 & a,
const CScalar & b )

◆ le() [29/88]

R3 le ( const R3 & a,
const R3 & b )

◆ le() [30/88]

R3 le ( const R3 & a,
const Scalar & b )

◆ le() [31/88]

R4 le ( const R4 & a,
const CScalar & b )

◆ le() [32/88]

R4 le ( const R4 & a,
const R4 & b )

◆ le() [33/88]

R4 le ( const R4 & a,
const Scalar & b )

◆ le() [34/88]

Rot le ( const Rot & a,
const CScalar & b )

◆ le() [35/88]

Rot le ( const Rot & a,
const Rot & b )

◆ le() [36/88]

Rot le ( const Rot & a,
const Scalar & b )

◆ le() [37/88]

Scalar le ( const Scalar & a,
const CScalar & b )

◆ le() [38/88]

MillerIndex le ( const Scalar & a,
const MillerIndex & b )

◆ le() [39/88]

Quaternion le ( const Scalar & a,
const Quaternion & b )

◆ le() [40/88]

R2 le ( const Scalar & a,
const R2 & b )

◆ le() [41/88]

R3 le ( const Scalar & a,
const R3 & b )

◆ le() [42/88]

R4 le ( const Scalar & a,
const R4 & b )

◆ le() [43/88]

Rot le ( const Scalar & a,
const Rot & b )

◆ le() [44/88]

Scalar le ( const Scalar & a,
const Scalar & b )

◆ le() [45/88]

SFFR4 le ( const Scalar & a,
const SFFR4 & b )

◆ le() [46/88]

SFR3 le ( const Scalar & a,
const SFR3 & b )

◆ le() [47/88]

SR2 le ( const Scalar & a,
const SR2 & b )

◆ le() [48/88]

SSR4 le ( const Scalar & a,
const SSR4 & b )

◆ le() [49/88]

SWR4 le ( const Scalar & a,
const SWR4 & b )

◆ le() [50/88]

Tensor le ( const Scalar & a,
const Tensor & b )

◆ le() [51/88]

Vec le ( const Scalar & a,
const Vec & b )

◆ le() [52/88]

WFFR4 le ( const Scalar & a,
const WFFR4 & b )

◆ le() [53/88]

WR2 le ( const Scalar & a,
const WR2 & b )

◆ le() [54/88]

WSR4 le ( const Scalar & a,
const WSR4 & b )

◆ le() [55/88]

WWR4 le ( const Scalar & a,
const WWR4 & b )

◆ le() [56/88]

SFFR4 le ( const SFFR4 & a,
const CScalar & b )

◆ le() [57/88]

SFFR4 le ( const SFFR4 & a,
const Scalar & b )

◆ le() [58/88]

SFFR4 le ( const SFFR4 & a,
const SFFR4 & b )

◆ le() [59/88]

SFR3 le ( const SFR3 & a,
const CScalar & b )

◆ le() [60/88]

SFR3 le ( const SFR3 & a,
const Scalar & b )

◆ le() [61/88]

SFR3 le ( const SFR3 & a,
const SFR3 & b )

◆ le() [62/88]

SR2 le ( const SR2 & a,
const CScalar & b )

◆ le() [63/88]

SR2 le ( const SR2 & a,
const Scalar & b )

◆ le() [64/88]

SR2 le ( const SR2 & a,
const SR2 & b )

◆ le() [65/88]

SSR4 le ( const SSR4 & a,
const CScalar & b )

◆ le() [66/88]

SSR4 le ( const SSR4 & a,
const Scalar & b )

◆ le() [67/88]

SSR4 le ( const SSR4 & a,
const SSR4 & b )

◆ le() [68/88]

SWR4 le ( const SWR4 & a,
const CScalar & b )

◆ le() [69/88]

SWR4 le ( const SWR4 & a,
const Scalar & b )

◆ le() [70/88]

SWR4 le ( const SWR4 & a,
const SWR4 & b )

◆ le() [71/88]

Tensor le ( const Tensor & a,
const CScalar & b )

◆ le() [72/88]

Tensor le ( const Tensor & a,
const Scalar & b )

◆ le() [73/88]

Tensor le ( const Tensor & a,
const Tensor & b )

◆ le() [74/88]

Vec le ( const Vec & a,
const CScalar & b )

◆ le() [75/88]

Vec le ( const Vec & a,
const Scalar & b )

◆ le() [76/88]

Vec le ( const Vec & a,
const Vec & b )

◆ le() [77/88]

WFFR4 le ( const WFFR4 & a,
const CScalar & b )

◆ le() [78/88]

WFFR4 le ( const WFFR4 & a,
const Scalar & b )

◆ le() [79/88]

WFFR4 le ( const WFFR4 & a,
const WFFR4 & b )

◆ le() [80/88]

WR2 le ( const WR2 & a,
const CScalar & b )

◆ le() [81/88]

WR2 le ( const WR2 & a,
const Scalar & b )

◆ le() [82/88]

WR2 le ( const WR2 & a,
const WR2 & b )

◆ le() [83/88]

WSR4 le ( const WSR4 & a,
const CScalar & b )

◆ le() [84/88]

WSR4 le ( const WSR4 & a,
const Scalar & b )

◆ le() [85/88]

WSR4 le ( const WSR4 & a,
const WSR4 & b )

◆ le() [86/88]

WWR4 le ( const WWR4 & a,
const CScalar & b )

◆ le() [87/88]

WWR4 le ( const WWR4 & a,
const Scalar & b )

◆ le() [88/88]

WWR4 le ( const WWR4 & a,
const WWR4 & b )

◆ load_input()

std::unique_ptr< Factory > load_input ( const std::filesystem::path & path,
const std::string & additional_input = "" )

A convenient function to parse all options from an input file.

Previously loaded input options will be discarded!

Warning
All threads share the same input options, so in principle this function is not intended to be called inside a threaded region.
Parameters
pathPath to the input file to be parsed
additional_inputAdditional cliargs to pass to the parser

◆ load_model()

std::shared_ptr< Model > load_model ( const std::filesystem::path & path,
const std::string & mname )

A convenient function to load an input file and get a model.

Parameters
pathPath to the input file to be parsed
mnameName of the model

◆ log() [1/18]

MillerIndex log ( const MillerIndex & a)

◆ log() [2/18]

Quaternion log ( const Quaternion & a)

◆ log() [3/18]

R2 log ( const R2 & a)

◆ log() [4/18]

R3 log ( const R3 & a)

◆ log() [5/18]

R4 log ( const R4 & a)

◆ log() [6/18]

Rot log ( const Rot & a)

◆ log() [7/18]

Scalar log ( const Scalar & a)

◆ log() [8/18]

SFFR4 log ( const SFFR4 & a)

◆ log() [9/18]

SFR3 log ( const SFR3 & a)

◆ log() [10/18]

SR2 log ( const SR2 & a)

◆ log() [11/18]

SSR4 log ( const SSR4 & a)

◆ log() [12/18]

SWR4 log ( const SWR4 & a)

◆ log() [13/18]

Tensor log ( const Tensor & a)

◆ log() [14/18]

Vec log ( const Vec & a)

◆ log() [15/18]

WFFR4 log ( const WFFR4 & a)

◆ log() [16/18]

WR2 log ( const WR2 & a)

◆ log() [17/18]

WSR4 log ( const WSR4 & a)

◆ log() [18/18]

WWR4 log ( const WWR4 & a)

◆ log10() [1/18]

MillerIndex log10 ( const MillerIndex & a)

◆ log10() [2/18]

Quaternion log10 ( const Quaternion & a)

◆ log10() [3/18]

R2 log10 ( const R2 & a)

◆ log10() [4/18]

R3 log10 ( const R3 & a)

◆ log10() [5/18]

R4 log10 ( const R4 & a)

◆ log10() [6/18]

Rot log10 ( const Rot & a)

◆ log10() [7/18]

Scalar log10 ( const Scalar & a)

◆ log10() [8/18]

SFFR4 log10 ( const SFFR4 & a)

◆ log10() [9/18]

SFR3 log10 ( const SFR3 & a)

◆ log10() [10/18]

SR2 log10 ( const SR2 & a)

◆ log10() [11/18]

SSR4 log10 ( const SSR4 & a)

◆ log10() [12/18]

SWR4 log10 ( const SWR4 & a)

◆ log10() [13/18]

Tensor log10 ( const Tensor & a)

◆ log10() [14/18]

Vec log10 ( const Vec & a)

◆ log10() [15/18]

WFFR4 log10 ( const WFFR4 & a)

◆ log10() [16/18]

WR2 log10 ( const WR2 & a)

◆ log10() [17/18]

WSR4 log10 ( const WSR4 & a)

◆ log10() [18/18]

WWR4 log10 ( const WWR4 & a)

◆ logical_and() [1/88]

MillerIndex logical_and ( const CScalar & a,
const MillerIndex & b )

◆ logical_and() [2/88]

Quaternion logical_and ( const CScalar & a,
const Quaternion & b )

◆ logical_and() [3/88]

R2 logical_and ( const CScalar & a,
const R2 & b )

◆ logical_and() [4/88]

R3 logical_and ( const CScalar & a,
const R3 & b )

◆ logical_and() [5/88]

R4 logical_and ( const CScalar & a,
const R4 & b )

◆ logical_and() [6/88]

Rot logical_and ( const CScalar & a,
const Rot & b )

◆ logical_and() [7/88]

Scalar logical_and ( const CScalar & a,
const Scalar & b )

◆ logical_and() [8/88]

SFFR4 logical_and ( const CScalar & a,
const SFFR4 & b )

◆ logical_and() [9/88]

SFR3 logical_and ( const CScalar & a,
const SFR3 & b )

◆ logical_and() [10/88]

SR2 logical_and ( const CScalar & a,
const SR2 & b )

◆ logical_and() [11/88]

SSR4 logical_and ( const CScalar & a,
const SSR4 & b )

◆ logical_and() [12/88]

SWR4 logical_and ( const CScalar & a,
const SWR4 & b )

◆ logical_and() [13/88]

Tensor logical_and ( const CScalar & a,
const Tensor & b )

◆ logical_and() [14/88]

Vec logical_and ( const CScalar & a,
const Vec & b )

◆ logical_and() [15/88]

WFFR4 logical_and ( const CScalar & a,
const WFFR4 & b )

◆ logical_and() [16/88]

WR2 logical_and ( const CScalar & a,
const WR2 & b )

◆ logical_and() [17/88]

WSR4 logical_and ( const CScalar & a,
const WSR4 & b )

◆ logical_and() [18/88]

WWR4 logical_and ( const CScalar & a,
const WWR4 & b )

◆ logical_and() [19/88]

MillerIndex logical_and ( const MillerIndex & a,
const CScalar & b )

◆ logical_and() [20/88]

MillerIndex logical_and ( const MillerIndex & a,
const MillerIndex & b )

◆ logical_and() [21/88]

MillerIndex logical_and ( const MillerIndex & a,
const Scalar & b )

◆ logical_and() [22/88]

Quaternion logical_and ( const Quaternion & a,
const CScalar & b )

◆ logical_and() [23/88]

Quaternion logical_and ( const Quaternion & a,
const Quaternion & b )

◆ logical_and() [24/88]

Quaternion logical_and ( const Quaternion & a,
const Scalar & b )

◆ logical_and() [25/88]

R2 logical_and ( const R2 & a,
const CScalar & b )

◆ logical_and() [26/88]

R2 logical_and ( const R2 & a,
const R2 & b )

◆ logical_and() [27/88]

R2 logical_and ( const R2 & a,
const Scalar & b )

◆ logical_and() [28/88]

R3 logical_and ( const R3 & a,
const CScalar & b )

◆ logical_and() [29/88]

R3 logical_and ( const R3 & a,
const R3 & b )

◆ logical_and() [30/88]

R3 logical_and ( const R3 & a,
const Scalar & b )

◆ logical_and() [31/88]

R4 logical_and ( const R4 & a,
const CScalar & b )

◆ logical_and() [32/88]

R4 logical_and ( const R4 & a,
const R4 & b )

◆ logical_and() [33/88]

R4 logical_and ( const R4 & a,
const Scalar & b )

◆ logical_and() [34/88]

Rot logical_and ( const Rot & a,
const CScalar & b )

◆ logical_and() [35/88]

Rot logical_and ( const Rot & a,
const Rot & b )

◆ logical_and() [36/88]

Rot logical_and ( const Rot & a,
const Scalar & b )

◆ logical_and() [37/88]

Scalar logical_and ( const Scalar & a,
const CScalar & b )

◆ logical_and() [38/88]

MillerIndex logical_and ( const Scalar & a,
const MillerIndex & b )

◆ logical_and() [39/88]

Quaternion logical_and ( const Scalar & a,
const Quaternion & b )

◆ logical_and() [40/88]

R2 logical_and ( const Scalar & a,
const R2 & b )

◆ logical_and() [41/88]

R3 logical_and ( const Scalar & a,
const R3 & b )

◆ logical_and() [42/88]

R4 logical_and ( const Scalar & a,
const R4 & b )

◆ logical_and() [43/88]

Rot logical_and ( const Scalar & a,
const Rot & b )

◆ logical_and() [44/88]

Scalar logical_and ( const Scalar & a,
const Scalar & b )

◆ logical_and() [45/88]

SFFR4 logical_and ( const Scalar & a,
const SFFR4 & b )

◆ logical_and() [46/88]

SFR3 logical_and ( const Scalar & a,
const SFR3 & b )

◆ logical_and() [47/88]

SR2 logical_and ( const Scalar & a,
const SR2 & b )

◆ logical_and() [48/88]

SSR4 logical_and ( const Scalar & a,
const SSR4 & b )

◆ logical_and() [49/88]

SWR4 logical_and ( const Scalar & a,
const SWR4 & b )

◆ logical_and() [50/88]

Tensor logical_and ( const Scalar & a,
const Tensor & b )

◆ logical_and() [51/88]

Vec logical_and ( const Scalar & a,
const Vec & b )

◆ logical_and() [52/88]

WFFR4 logical_and ( const Scalar & a,
const WFFR4 & b )

◆ logical_and() [53/88]

WR2 logical_and ( const Scalar & a,
const WR2 & b )

◆ logical_and() [54/88]

WSR4 logical_and ( const Scalar & a,
const WSR4 & b )

◆ logical_and() [55/88]

WWR4 logical_and ( const Scalar & a,
const WWR4 & b )

◆ logical_and() [56/88]

SFFR4 logical_and ( const SFFR4 & a,
const CScalar & b )

◆ logical_and() [57/88]

SFFR4 logical_and ( const SFFR4 & a,
const Scalar & b )

◆ logical_and() [58/88]

SFFR4 logical_and ( const SFFR4 & a,
const SFFR4 & b )

◆ logical_and() [59/88]

SFR3 logical_and ( const SFR3 & a,
const CScalar & b )

◆ logical_and() [60/88]

SFR3 logical_and ( const SFR3 & a,
const Scalar & b )

◆ logical_and() [61/88]

SFR3 logical_and ( const SFR3 & a,
const SFR3 & b )

◆ logical_and() [62/88]

SR2 logical_and ( const SR2 & a,
const CScalar & b )

◆ logical_and() [63/88]

SR2 logical_and ( const SR2 & a,
const Scalar & b )

◆ logical_and() [64/88]

SR2 logical_and ( const SR2 & a,
const SR2 & b )

◆ logical_and() [65/88]

SSR4 logical_and ( const SSR4 & a,
const CScalar & b )

◆ logical_and() [66/88]

SSR4 logical_and ( const SSR4 & a,
const Scalar & b )

◆ logical_and() [67/88]

SSR4 logical_and ( const SSR4 & a,
const SSR4 & b )

◆ logical_and() [68/88]

SWR4 logical_and ( const SWR4 & a,
const CScalar & b )

◆ logical_and() [69/88]

SWR4 logical_and ( const SWR4 & a,
const Scalar & b )

◆ logical_and() [70/88]

SWR4 logical_and ( const SWR4 & a,
const SWR4 & b )

◆ logical_and() [71/88]

Tensor logical_and ( const Tensor & a,
const CScalar & b )

◆ logical_and() [72/88]

Tensor logical_and ( const Tensor & a,
const Scalar & b )

◆ logical_and() [73/88]

Tensor logical_and ( const Tensor & a,
const Tensor & b )

◆ logical_and() [74/88]

Vec logical_and ( const Vec & a,
const CScalar & b )

◆ logical_and() [75/88]

Vec logical_and ( const Vec & a,
const Scalar & b )

◆ logical_and() [76/88]

Vec logical_and ( const Vec & a,
const Vec & b )

◆ logical_and() [77/88]

WFFR4 logical_and ( const WFFR4 & a,
const CScalar & b )

◆ logical_and() [78/88]

WFFR4 logical_and ( const WFFR4 & a,
const Scalar & b )

◆ logical_and() [79/88]

WFFR4 logical_and ( const WFFR4 & a,
const WFFR4 & b )

◆ logical_and() [80/88]

WR2 logical_and ( const WR2 & a,
const CScalar & b )

◆ logical_and() [81/88]

WR2 logical_and ( const WR2 & a,
const Scalar & b )

◆ logical_and() [82/88]

WR2 logical_and ( const WR2 & a,
const WR2 & b )

◆ logical_and() [83/88]

WSR4 logical_and ( const WSR4 & a,
const CScalar & b )

◆ logical_and() [84/88]

WSR4 logical_and ( const WSR4 & a,
const Scalar & b )

◆ logical_and() [85/88]

WSR4 logical_and ( const WSR4 & a,
const WSR4 & b )

◆ logical_and() [86/88]

WWR4 logical_and ( const WWR4 & a,
const CScalar & b )

◆ logical_and() [87/88]

WWR4 logical_and ( const WWR4 & a,
const Scalar & b )

◆ logical_and() [88/88]

WWR4 logical_and ( const WWR4 & a,
const WWR4 & b )

◆ logical_not() [1/18]

MillerIndex logical_not ( const MillerIndex & a)

◆ logical_not() [2/18]

Quaternion logical_not ( const Quaternion & a)

◆ logical_not() [3/18]

R2 logical_not ( const R2 & a)

◆ logical_not() [4/18]

R3 logical_not ( const R3 & a)

◆ logical_not() [5/18]

R4 logical_not ( const R4 & a)

◆ logical_not() [6/18]

Rot logical_not ( const Rot & a)

◆ logical_not() [7/18]

Scalar logical_not ( const Scalar & a)

◆ logical_not() [8/18]

SFFR4 logical_not ( const SFFR4 & a)

◆ logical_not() [9/18]

SFR3 logical_not ( const SFR3 & a)

◆ logical_not() [10/18]

SR2 logical_not ( const SR2 & a)

◆ logical_not() [11/18]

SSR4 logical_not ( const SSR4 & a)

◆ logical_not() [12/18]

SWR4 logical_not ( const SWR4 & a)

◆ logical_not() [13/18]

Tensor logical_not ( const Tensor & a)

◆ logical_not() [14/18]

Vec logical_not ( const Vec & a)

◆ logical_not() [15/18]

WFFR4 logical_not ( const WFFR4 & a)

◆ logical_not() [16/18]

WR2 logical_not ( const WR2 & a)

◆ logical_not() [17/18]

WSR4 logical_not ( const WSR4 & a)

◆ logical_not() [18/18]

WWR4 logical_not ( const WWR4 & a)

◆ logical_or() [1/88]

MillerIndex logical_or ( const CScalar & a,
const MillerIndex & b )

◆ logical_or() [2/88]

Quaternion logical_or ( const CScalar & a,
const Quaternion & b )

◆ logical_or() [3/88]

R2 logical_or ( const CScalar & a,
const R2 & b )

◆ logical_or() [4/88]

R3 logical_or ( const CScalar & a,
const R3 & b )

◆ logical_or() [5/88]

R4 logical_or ( const CScalar & a,
const R4 & b )

◆ logical_or() [6/88]

Rot logical_or ( const CScalar & a,
const Rot & b )

◆ logical_or() [7/88]

Scalar logical_or ( const CScalar & a,
const Scalar & b )

◆ logical_or() [8/88]

SFFR4 logical_or ( const CScalar & a,
const SFFR4 & b )

◆ logical_or() [9/88]

SFR3 logical_or ( const CScalar & a,
const SFR3 & b )

◆ logical_or() [10/88]

SR2 logical_or ( const CScalar & a,
const SR2 & b )

◆ logical_or() [11/88]

SSR4 logical_or ( const CScalar & a,
const SSR4 & b )

◆ logical_or() [12/88]

SWR4 logical_or ( const CScalar & a,
const SWR4 & b )

◆ logical_or() [13/88]

Tensor logical_or ( const CScalar & a,
const Tensor & b )

◆ logical_or() [14/88]

Vec logical_or ( const CScalar & a,
const Vec & b )

◆ logical_or() [15/88]

WFFR4 logical_or ( const CScalar & a,
const WFFR4 & b )

◆ logical_or() [16/88]

WR2 logical_or ( const CScalar & a,
const WR2 & b )

◆ logical_or() [17/88]

WSR4 logical_or ( const CScalar & a,
const WSR4 & b )

◆ logical_or() [18/88]

WWR4 logical_or ( const CScalar & a,
const WWR4 & b )

◆ logical_or() [19/88]

MillerIndex logical_or ( const MillerIndex & a,
const CScalar & b )

◆ logical_or() [20/88]

MillerIndex logical_or ( const MillerIndex & a,
const MillerIndex & b )

◆ logical_or() [21/88]

MillerIndex logical_or ( const MillerIndex & a,
const Scalar & b )

◆ logical_or() [22/88]

Quaternion logical_or ( const Quaternion & a,
const CScalar & b )

◆ logical_or() [23/88]

Quaternion logical_or ( const Quaternion & a,
const Quaternion & b )

◆ logical_or() [24/88]

Quaternion logical_or ( const Quaternion & a,
const Scalar & b )

◆ logical_or() [25/88]

R2 logical_or ( const R2 & a,
const CScalar & b )

◆ logical_or() [26/88]

R2 logical_or ( const R2 & a,
const R2 & b )

◆ logical_or() [27/88]

R2 logical_or ( const R2 & a,
const Scalar & b )

◆ logical_or() [28/88]

R3 logical_or ( const R3 & a,
const CScalar & b )

◆ logical_or() [29/88]

R3 logical_or ( const R3 & a,
const R3 & b )

◆ logical_or() [30/88]

R3 logical_or ( const R3 & a,
const Scalar & b )

◆ logical_or() [31/88]

R4 logical_or ( const R4 & a,
const CScalar & b )

◆ logical_or() [32/88]

R4 logical_or ( const R4 & a,
const R4 & b )

◆ logical_or() [33/88]

R4 logical_or ( const R4 & a,
const Scalar & b )

◆ logical_or() [34/88]

Rot logical_or ( const Rot & a,
const CScalar & b )

◆ logical_or() [35/88]

Rot logical_or ( const Rot & a,
const Rot & b )

◆ logical_or() [36/88]

Rot logical_or ( const Rot & a,
const Scalar & b )

◆ logical_or() [37/88]

Scalar logical_or ( const Scalar & a,
const CScalar & b )

◆ logical_or() [38/88]

MillerIndex logical_or ( const Scalar & a,
const MillerIndex & b )

◆ logical_or() [39/88]

Quaternion logical_or ( const Scalar & a,
const Quaternion & b )

◆ logical_or() [40/88]

R2 logical_or ( const Scalar & a,
const R2 & b )

◆ logical_or() [41/88]

R3 logical_or ( const Scalar & a,
const R3 & b )

◆ logical_or() [42/88]

R4 logical_or ( const Scalar & a,
const R4 & b )

◆ logical_or() [43/88]

Rot logical_or ( const Scalar & a,
const Rot & b )

◆ logical_or() [44/88]

Scalar logical_or ( const Scalar & a,
const Scalar & b )

◆ logical_or() [45/88]

SFFR4 logical_or ( const Scalar & a,
const SFFR4 & b )

◆ logical_or() [46/88]

SFR3 logical_or ( const Scalar & a,
const SFR3 & b )

◆ logical_or() [47/88]

SR2 logical_or ( const Scalar & a,
const SR2 & b )

◆ logical_or() [48/88]

SSR4 logical_or ( const Scalar & a,
const SSR4 & b )

◆ logical_or() [49/88]

SWR4 logical_or ( const Scalar & a,
const SWR4 & b )

◆ logical_or() [50/88]

Tensor logical_or ( const Scalar & a,
const Tensor & b )

◆ logical_or() [51/88]

Vec logical_or ( const Scalar & a,
const Vec & b )

◆ logical_or() [52/88]

WFFR4 logical_or ( const Scalar & a,
const WFFR4 & b )

◆ logical_or() [53/88]

WR2 logical_or ( const Scalar & a,
const WR2 & b )

◆ logical_or() [54/88]

WSR4 logical_or ( const Scalar & a,
const WSR4 & b )

◆ logical_or() [55/88]

WWR4 logical_or ( const Scalar & a,
const WWR4 & b )

◆ logical_or() [56/88]

SFFR4 logical_or ( const SFFR4 & a,
const CScalar & b )

◆ logical_or() [57/88]

SFFR4 logical_or ( const SFFR4 & a,
const Scalar & b )

◆ logical_or() [58/88]

SFFR4 logical_or ( const SFFR4 & a,
const SFFR4 & b )

◆ logical_or() [59/88]

SFR3 logical_or ( const SFR3 & a,
const CScalar & b )

◆ logical_or() [60/88]

SFR3 logical_or ( const SFR3 & a,
const Scalar & b )

◆ logical_or() [61/88]

SFR3 logical_or ( const SFR3 & a,
const SFR3 & b )

◆ logical_or() [62/88]

SR2 logical_or ( const SR2 & a,
const CScalar & b )

◆ logical_or() [63/88]

SR2 logical_or ( const SR2 & a,
const Scalar & b )

◆ logical_or() [64/88]

SR2 logical_or ( const SR2 & a,
const SR2 & b )

◆ logical_or() [65/88]

SSR4 logical_or ( const SSR4 & a,
const CScalar & b )

◆ logical_or() [66/88]

SSR4 logical_or ( const SSR4 & a,
const Scalar & b )

◆ logical_or() [67/88]

SSR4 logical_or ( const SSR4 & a,
const SSR4 & b )

◆ logical_or() [68/88]

SWR4 logical_or ( const SWR4 & a,
const CScalar & b )

◆ logical_or() [69/88]

SWR4 logical_or ( const SWR4 & a,
const Scalar & b )

◆ logical_or() [70/88]

SWR4 logical_or ( const SWR4 & a,
const SWR4 & b )

◆ logical_or() [71/88]

Tensor logical_or ( const Tensor & a,
const CScalar & b )

◆ logical_or() [72/88]

Tensor logical_or ( const Tensor & a,
const Scalar & b )

◆ logical_or() [73/88]

Tensor logical_or ( const Tensor & a,
const Tensor & b )

◆ logical_or() [74/88]

Vec logical_or ( const Vec & a,
const CScalar & b )

◆ logical_or() [75/88]

Vec logical_or ( const Vec & a,
const Scalar & b )

◆ logical_or() [76/88]

Vec logical_or ( const Vec & a,
const Vec & b )

◆ logical_or() [77/88]

WFFR4 logical_or ( const WFFR4 & a,
const CScalar & b )

◆ logical_or() [78/88]

WFFR4 logical_or ( const WFFR4 & a,
const Scalar & b )

◆ logical_or() [79/88]

WFFR4 logical_or ( const WFFR4 & a,
const WFFR4 & b )

◆ logical_or() [80/88]

WR2 logical_or ( const WR2 & a,
const CScalar & b )

◆ logical_or() [81/88]

WR2 logical_or ( const WR2 & a,
const Scalar & b )

◆ logical_or() [82/88]

WR2 logical_or ( const WR2 & a,
const WR2 & b )

◆ logical_or() [83/88]

WSR4 logical_or ( const WSR4 & a,
const CScalar & b )

◆ logical_or() [84/88]

WSR4 logical_or ( const WSR4 & a,
const Scalar & b )

◆ logical_or() [85/88]

WSR4 logical_or ( const WSR4 & a,
const WSR4 & b )

◆ logical_or() [86/88]

WWR4 logical_or ( const WWR4 & a,
const CScalar & b )

◆ logical_or() [87/88]

WWR4 logical_or ( const WWR4 & a,
const Scalar & b )

◆ logical_or() [88/88]

WWR4 logical_or ( const WWR4 & a,
const WWR4 & b )

◆ logical_xor() [1/88]

MillerIndex logical_xor ( const CScalar & a,
const MillerIndex & b )

◆ logical_xor() [2/88]

Quaternion logical_xor ( const CScalar & a,
const Quaternion & b )

◆ logical_xor() [3/88]

R2 logical_xor ( const CScalar & a,
const R2 & b )

◆ logical_xor() [4/88]

R3 logical_xor ( const CScalar & a,
const R3 & b )

◆ logical_xor() [5/88]

R4 logical_xor ( const CScalar & a,
const R4 & b )

◆ logical_xor() [6/88]

Rot logical_xor ( const CScalar & a,
const Rot & b )

◆ logical_xor() [7/88]

Scalar logical_xor ( const CScalar & a,
const Scalar & b )

◆ logical_xor() [8/88]

SFFR4 logical_xor ( const CScalar & a,
const SFFR4 & b )

◆ logical_xor() [9/88]

SFR3 logical_xor ( const CScalar & a,
const SFR3 & b )

◆ logical_xor() [10/88]

SR2 logical_xor ( const CScalar & a,
const SR2 & b )

◆ logical_xor() [11/88]

SSR4 logical_xor ( const CScalar & a,
const SSR4 & b )

◆ logical_xor() [12/88]

SWR4 logical_xor ( const CScalar & a,
const SWR4 & b )

◆ logical_xor() [13/88]

Tensor logical_xor ( const CScalar & a,
const Tensor & b )

◆ logical_xor() [14/88]

Vec logical_xor ( const CScalar & a,
const Vec & b )

◆ logical_xor() [15/88]

WFFR4 logical_xor ( const CScalar & a,
const WFFR4 & b )

◆ logical_xor() [16/88]

WR2 logical_xor ( const CScalar & a,
const WR2 & b )

◆ logical_xor() [17/88]

WSR4 logical_xor ( const CScalar & a,
const WSR4 & b )

◆ logical_xor() [18/88]

WWR4 logical_xor ( const CScalar & a,
const WWR4 & b )

◆ logical_xor() [19/88]

MillerIndex logical_xor ( const MillerIndex & a,
const CScalar & b )

◆ logical_xor() [20/88]

MillerIndex logical_xor ( const MillerIndex & a,
const MillerIndex & b )

◆ logical_xor() [21/88]

MillerIndex logical_xor ( const MillerIndex & a,
const Scalar & b )

◆ logical_xor() [22/88]

Quaternion logical_xor ( const Quaternion & a,
const CScalar & b )

◆ logical_xor() [23/88]

Quaternion logical_xor ( const Quaternion & a,
const Quaternion & b )

◆ logical_xor() [24/88]

Quaternion logical_xor ( const Quaternion & a,
const Scalar & b )

◆ logical_xor() [25/88]

R2 logical_xor ( const R2 & a,
const CScalar & b )

◆ logical_xor() [26/88]

R2 logical_xor ( const R2 & a,
const R2 & b )

◆ logical_xor() [27/88]

R2 logical_xor ( const R2 & a,
const Scalar & b )

◆ logical_xor() [28/88]

R3 logical_xor ( const R3 & a,
const CScalar & b )

◆ logical_xor() [29/88]

R3 logical_xor ( const R3 & a,
const R3 & b )

◆ logical_xor() [30/88]

R3 logical_xor ( const R3 & a,
const Scalar & b )

◆ logical_xor() [31/88]

R4 logical_xor ( const R4 & a,
const CScalar & b )

◆ logical_xor() [32/88]

R4 logical_xor ( const R4 & a,
const R4 & b )

◆ logical_xor() [33/88]

R4 logical_xor ( const R4 & a,
const Scalar & b )

◆ logical_xor() [34/88]

Rot logical_xor ( const Rot & a,
const CScalar & b )

◆ logical_xor() [35/88]

Rot logical_xor ( const Rot & a,
const Rot & b )

◆ logical_xor() [36/88]

Rot logical_xor ( const Rot & a,
const Scalar & b )

◆ logical_xor() [37/88]

Scalar logical_xor ( const Scalar & a,
const CScalar & b )

◆ logical_xor() [38/88]

MillerIndex logical_xor ( const Scalar & a,
const MillerIndex & b )

◆ logical_xor() [39/88]

Quaternion logical_xor ( const Scalar & a,
const Quaternion & b )

◆ logical_xor() [40/88]

R2 logical_xor ( const Scalar & a,
const R2 & b )

◆ logical_xor() [41/88]

R3 logical_xor ( const Scalar & a,
const R3 & b )

◆ logical_xor() [42/88]

R4 logical_xor ( const Scalar & a,
const R4 & b )

◆ logical_xor() [43/88]

Rot logical_xor ( const Scalar & a,
const Rot & b )

◆ logical_xor() [44/88]

Scalar logical_xor ( const Scalar & a,
const Scalar & b )

◆ logical_xor() [45/88]

SFFR4 logical_xor ( const Scalar & a,
const SFFR4 & b )

◆ logical_xor() [46/88]

SFR3 logical_xor ( const Scalar & a,
const SFR3 & b )

◆ logical_xor() [47/88]

SR2 logical_xor ( const Scalar & a,
const SR2 & b )

◆ logical_xor() [48/88]

SSR4 logical_xor ( const Scalar & a,
const SSR4 & b )

◆ logical_xor() [49/88]

SWR4 logical_xor ( const Scalar & a,
const SWR4 & b )

◆ logical_xor() [50/88]

Tensor logical_xor ( const Scalar & a,
const Tensor & b )

◆ logical_xor() [51/88]

Vec logical_xor ( const Scalar & a,
const Vec & b )

◆ logical_xor() [52/88]

WFFR4 logical_xor ( const Scalar & a,
const WFFR4 & b )

◆ logical_xor() [53/88]

WR2 logical_xor ( const Scalar & a,
const WR2 & b )

◆ logical_xor() [54/88]

WSR4 logical_xor ( const Scalar & a,
const WSR4 & b )

◆ logical_xor() [55/88]

WWR4 logical_xor ( const Scalar & a,
const WWR4 & b )

◆ logical_xor() [56/88]

SFFR4 logical_xor ( const SFFR4 & a,
const CScalar & b )

◆ logical_xor() [57/88]

SFFR4 logical_xor ( const SFFR4 & a,
const Scalar & b )

◆ logical_xor() [58/88]

SFFR4 logical_xor ( const SFFR4 & a,
const SFFR4 & b )

◆ logical_xor() [59/88]

SFR3 logical_xor ( const SFR3 & a,
const CScalar & b )

◆ logical_xor() [60/88]

SFR3 logical_xor ( const SFR3 & a,
const Scalar & b )

◆ logical_xor() [61/88]

SFR3 logical_xor ( const SFR3 & a,
const SFR3 & b )

◆ logical_xor() [62/88]

SR2 logical_xor ( const SR2 & a,
const CScalar & b )

◆ logical_xor() [63/88]

SR2 logical_xor ( const SR2 & a,
const Scalar & b )

◆ logical_xor() [64/88]

SR2 logical_xor ( const SR2 & a,
const SR2 & b )

◆ logical_xor() [65/88]

SSR4 logical_xor ( const SSR4 & a,
const CScalar & b )

◆ logical_xor() [66/88]

SSR4 logical_xor ( const SSR4 & a,
const Scalar & b )

◆ logical_xor() [67/88]

SSR4 logical_xor ( const SSR4 & a,
const SSR4 & b )

◆ logical_xor() [68/88]

SWR4 logical_xor ( const SWR4 & a,
const CScalar & b )

◆ logical_xor() [69/88]

SWR4 logical_xor ( const SWR4 & a,
const Scalar & b )

◆ logical_xor() [70/88]

SWR4 logical_xor ( const SWR4 & a,
const SWR4 & b )

◆ logical_xor() [71/88]

Tensor logical_xor ( const Tensor & a,
const CScalar & b )

◆ logical_xor() [72/88]

Tensor logical_xor ( const Tensor & a,
const Scalar & b )

◆ logical_xor() [73/88]

Tensor logical_xor ( const Tensor & a,
const Tensor & b )

◆ logical_xor() [74/88]

Vec logical_xor ( const Vec & a,
const CScalar & b )

◆ logical_xor() [75/88]

Vec logical_xor ( const Vec & a,
const Scalar & b )

◆ logical_xor() [76/88]

Vec logical_xor ( const Vec & a,
const Vec & b )

◆ logical_xor() [77/88]

WFFR4 logical_xor ( const WFFR4 & a,
const CScalar & b )

◆ logical_xor() [78/88]

WFFR4 logical_xor ( const WFFR4 & a,
const Scalar & b )

◆ logical_xor() [79/88]

WFFR4 logical_xor ( const WFFR4 & a,
const WFFR4 & b )

◆ logical_xor() [80/88]

WR2 logical_xor ( const WR2 & a,
const CScalar & b )

◆ logical_xor() [81/88]

WR2 logical_xor ( const WR2 & a,
const Scalar & b )

◆ logical_xor() [82/88]

WR2 logical_xor ( const WR2 & a,
const WR2 & b )

◆ logical_xor() [83/88]

WSR4 logical_xor ( const WSR4 & a,
const CScalar & b )

◆ logical_xor() [84/88]

WSR4 logical_xor ( const WSR4 & a,
const Scalar & b )

◆ logical_xor() [85/88]

WSR4 logical_xor ( const WSR4 & a,
const WSR4 & b )

◆ logical_xor() [86/88]

WWR4 logical_xor ( const WWR4 & a,
const CScalar & b )

◆ logical_xor() [87/88]

WWR4 logical_xor ( const WWR4 & a,
const Scalar & b )

◆ logical_xor() [88/88]

WWR4 logical_xor ( const WWR4 & a,
const WWR4 & b )

◆ lt() [1/88]

MillerIndex lt ( const CScalar & a,
const MillerIndex & b )

◆ lt() [2/88]

Quaternion lt ( const CScalar & a,
const Quaternion & b )

◆ lt() [3/88]

R2 lt ( const CScalar & a,
const R2 & b )

◆ lt() [4/88]

R3 lt ( const CScalar & a,
const R3 & b )

◆ lt() [5/88]

R4 lt ( const CScalar & a,
const R4 & b )

◆ lt() [6/88]

Rot lt ( const CScalar & a,
const Rot & b )

◆ lt() [7/88]

Scalar lt ( const CScalar & a,
const Scalar & b )

◆ lt() [8/88]

SFFR4 lt ( const CScalar & a,
const SFFR4 & b )

◆ lt() [9/88]

SFR3 lt ( const CScalar & a,
const SFR3 & b )

◆ lt() [10/88]

SR2 lt ( const CScalar & a,
const SR2 & b )

◆ lt() [11/88]

SSR4 lt ( const CScalar & a,
const SSR4 & b )

◆ lt() [12/88]

SWR4 lt ( const CScalar & a,
const SWR4 & b )

◆ lt() [13/88]

Tensor lt ( const CScalar & a,
const Tensor & b )

◆ lt() [14/88]

Vec lt ( const CScalar & a,
const Vec & b )

◆ lt() [15/88]

WFFR4 lt ( const CScalar & a,
const WFFR4 & b )

◆ lt() [16/88]

WR2 lt ( const CScalar & a,
const WR2 & b )

◆ lt() [17/88]

WSR4 lt ( const CScalar & a,
const WSR4 & b )

◆ lt() [18/88]

WWR4 lt ( const CScalar & a,
const WWR4 & b )

◆ lt() [19/88]

MillerIndex lt ( const MillerIndex & a,
const CScalar & b )

◆ lt() [20/88]

MillerIndex lt ( const MillerIndex & a,
const MillerIndex & b )

◆ lt() [21/88]

MillerIndex lt ( const MillerIndex & a,
const Scalar & b )

◆ lt() [22/88]

Quaternion lt ( const Quaternion & a,
const CScalar & b )

◆ lt() [23/88]

Quaternion lt ( const Quaternion & a,
const Quaternion & b )

◆ lt() [24/88]

Quaternion lt ( const Quaternion & a,
const Scalar & b )

◆ lt() [25/88]

R2 lt ( const R2 & a,
const CScalar & b )

◆ lt() [26/88]

R2 lt ( const R2 & a,
const R2 & b )

◆ lt() [27/88]

R2 lt ( const R2 & a,
const Scalar & b )

◆ lt() [28/88]

R3 lt ( const R3 & a,
const CScalar & b )

◆ lt() [29/88]

R3 lt ( const R3 & a,
const R3 & b )

◆ lt() [30/88]

R3 lt ( const R3 & a,
const Scalar & b )

◆ lt() [31/88]

R4 lt ( const R4 & a,
const CScalar & b )

◆ lt() [32/88]

R4 lt ( const R4 & a,
const R4 & b )

◆ lt() [33/88]

R4 lt ( const R4 & a,
const Scalar & b )

◆ lt() [34/88]

Rot lt ( const Rot & a,
const CScalar & b )

◆ lt() [35/88]

Rot lt ( const Rot & a,
const Rot & b )

◆ lt() [36/88]

Rot lt ( const Rot & a,
const Scalar & b )

◆ lt() [37/88]

Scalar lt ( const Scalar & a,
const CScalar & b )

◆ lt() [38/88]

MillerIndex lt ( const Scalar & a,
const MillerIndex & b )

◆ lt() [39/88]

Quaternion lt ( const Scalar & a,
const Quaternion & b )

◆ lt() [40/88]

R2 lt ( const Scalar & a,
const R2 & b )

◆ lt() [41/88]

R3 lt ( const Scalar & a,
const R3 & b )

◆ lt() [42/88]

R4 lt ( const Scalar & a,
const R4 & b )

◆ lt() [43/88]

Rot lt ( const Scalar & a,
const Rot & b )

◆ lt() [44/88]

Scalar lt ( const Scalar & a,
const Scalar & b )

◆ lt() [45/88]

SFFR4 lt ( const Scalar & a,
const SFFR4 & b )

◆ lt() [46/88]

SFR3 lt ( const Scalar & a,
const SFR3 & b )

◆ lt() [47/88]

SR2 lt ( const Scalar & a,
const SR2 & b )

◆ lt() [48/88]

SSR4 lt ( const Scalar & a,
const SSR4 & b )

◆ lt() [49/88]

SWR4 lt ( const Scalar & a,
const SWR4 & b )

◆ lt() [50/88]

Tensor lt ( const Scalar & a,
const Tensor & b )

◆ lt() [51/88]

Vec lt ( const Scalar & a,
const Vec & b )

◆ lt() [52/88]

WFFR4 lt ( const Scalar & a,
const WFFR4 & b )

◆ lt() [53/88]

WR2 lt ( const Scalar & a,
const WR2 & b )

◆ lt() [54/88]

WSR4 lt ( const Scalar & a,
const WSR4 & b )

◆ lt() [55/88]

WWR4 lt ( const Scalar & a,
const WWR4 & b )

◆ lt() [56/88]

SFFR4 lt ( const SFFR4 & a,
const CScalar & b )

◆ lt() [57/88]

SFFR4 lt ( const SFFR4 & a,
const Scalar & b )

◆ lt() [58/88]

SFFR4 lt ( const SFFR4 & a,
const SFFR4 & b )

◆ lt() [59/88]

SFR3 lt ( const SFR3 & a,
const CScalar & b )

◆ lt() [60/88]

SFR3 lt ( const SFR3 & a,
const Scalar & b )

◆ lt() [61/88]

SFR3 lt ( const SFR3 & a,
const SFR3 & b )

◆ lt() [62/88]

SR2 lt ( const SR2 & a,
const CScalar & b )

◆ lt() [63/88]

SR2 lt ( const SR2 & a,
const Scalar & b )

◆ lt() [64/88]

SR2 lt ( const SR2 & a,
const SR2 & b )

◆ lt() [65/88]

SSR4 lt ( const SSR4 & a,
const CScalar & b )

◆ lt() [66/88]

SSR4 lt ( const SSR4 & a,
const Scalar & b )

◆ lt() [67/88]

SSR4 lt ( const SSR4 & a,
const SSR4 & b )

◆ lt() [68/88]

SWR4 lt ( const SWR4 & a,
const CScalar & b )

◆ lt() [69/88]

SWR4 lt ( const SWR4 & a,
const Scalar & b )

◆ lt() [70/88]

SWR4 lt ( const SWR4 & a,
const SWR4 & b )

◆ lt() [71/88]

Tensor lt ( const Tensor & a,
const CScalar & b )

◆ lt() [72/88]

Tensor lt ( const Tensor & a,
const Scalar & b )

◆ lt() [73/88]

Tensor lt ( const Tensor & a,
const Tensor & b )

◆ lt() [74/88]

Vec lt ( const Vec & a,
const CScalar & b )

◆ lt() [75/88]

Vec lt ( const Vec & a,
const Scalar & b )

◆ lt() [76/88]

Vec lt ( const Vec & a,
const Vec & b )

◆ lt() [77/88]

WFFR4 lt ( const WFFR4 & a,
const CScalar & b )

◆ lt() [78/88]

WFFR4 lt ( const WFFR4 & a,
const Scalar & b )

◆ lt() [79/88]

WFFR4 lt ( const WFFR4 & a,
const WFFR4 & b )

◆ lt() [80/88]

WR2 lt ( const WR2 & a,
const CScalar & b )

◆ lt() [81/88]

WR2 lt ( const WR2 & a,
const Scalar & b )

◆ lt() [82/88]

WR2 lt ( const WR2 & a,
const WR2 & b )

◆ lt() [83/88]

WSR4 lt ( const WSR4 & a,
const CScalar & b )

◆ lt() [84/88]

WSR4 lt ( const WSR4 & a,
const Scalar & b )

◆ lt() [85/88]

WSR4 lt ( const WSR4 & a,
const WSR4 & b )

◆ lt() [86/88]

WWR4 lt ( const WWR4 & a,
const CScalar & b )

◆ lt() [87/88]

WWR4 lt ( const WWR4 & a,
const Scalar & b )

◆ lt() [88/88]

WWR4 lt ( const WWR4 & a,
const WWR4 & b )

◆ macaulay() [1/18]

MillerIndex macaulay ( const MillerIndex & a)

◆ macaulay() [2/18]

Quaternion macaulay ( const Quaternion & a)

◆ macaulay() [3/18]

R2 macaulay ( const R2 & a)

◆ macaulay() [4/18]

R3 macaulay ( const R3 & a)

◆ macaulay() [5/18]

R4 macaulay ( const R4 & a)

◆ macaulay() [6/18]

Rot macaulay ( const Rot & a)

◆ macaulay() [7/18]

Scalar macaulay ( const Scalar & a)

◆ macaulay() [8/18]

SFFR4 macaulay ( const SFFR4 & a)

◆ macaulay() [9/18]

SFR3 macaulay ( const SFR3 & a)

◆ macaulay() [10/18]

SR2 macaulay ( const SR2 & a)

◆ macaulay() [11/18]

SSR4 macaulay ( const SSR4 & a)

◆ macaulay() [12/18]

SWR4 macaulay ( const SWR4 & a)

◆ macaulay() [13/18]

Tensor macaulay ( const Tensor & a)

◆ macaulay() [14/18]

Vec macaulay ( const Vec & a)

◆ macaulay() [15/18]

WFFR4 macaulay ( const WFFR4 & a)

◆ macaulay() [16/18]

WR2 macaulay ( const WR2 & a)

◆ macaulay() [17/18]

WSR4 macaulay ( const WSR4 & a)

◆ macaulay() [18/18]

WWR4 macaulay ( const WWR4 & a)

◆ machine_precision()

double machine_precision ( Dtype )

◆ make_tensors()

template<class Tuple, std::size_t... I>
auto make_tensors ( Tuple && t,
std::index_sequence< I... > ,
const TensorOptions & options )

◆ mandel_factor()

double mandel_factor ( Size i)
inlineconstexpr

◆ mandel_to_full()

Tensor mandel_to_full ( const Tensor & mandel,
Size dim = 0 )

Convert a Tensor from Mandel notation to full notation.

See full_to_mandel for a detailed explanation.

Parameters
mandelThe input tensor in Mandel notation
dimThe base dimension where the symmetric axes start
Returns
Tensor The resulting tensor in full notation.

◆ minimum() [1/18]

MillerIndex minimum ( const MillerIndex & a,
const MillerIndex & b )

◆ minimum() [2/18]

Quaternion minimum ( const Quaternion & a,
const Quaternion & b )

◆ minimum() [3/18]

R2 minimum ( const R2 & a,
const R2 & b )

◆ minimum() [4/18]

R3 minimum ( const R3 & a,
const R3 & b )

◆ minimum() [5/18]

R4 minimum ( const R4 & a,
const R4 & b )

◆ minimum() [6/18]

Rot minimum ( const Rot & a,
const Rot & b )

◆ minimum() [7/18]

Scalar minimum ( const Scalar & a,
const Scalar & b )

◆ minimum() [8/18]

SFFR4 minimum ( const SFFR4 & a,
const SFFR4 & b )

◆ minimum() [9/18]

SFR3 minimum ( const SFR3 & a,
const SFR3 & b )

◆ minimum() [10/18]

SR2 minimum ( const SR2 & a,
const SR2 & b )

◆ minimum() [11/18]

SSR4 minimum ( const SSR4 & a,
const SSR4 & b )

◆ minimum() [12/18]

SWR4 minimum ( const SWR4 & a,
const SWR4 & b )

◆ minimum() [13/18]

Tensor minimum ( const Tensor & a,
const Tensor & b )

◆ minimum() [14/18]

Vec minimum ( const Vec & a,
const Vec & b )

◆ minimum() [15/18]

WFFR4 minimum ( const WFFR4 & a,
const WFFR4 & b )

◆ minimum() [16/18]

WR2 minimum ( const WR2 & a,
const WR2 & b )

◆ minimum() [17/18]

WSR4 minimum ( const WSR4 & a,
const WSR4 & b )

◆ minimum() [18/18]

WWR4 minimum ( const WWR4 & a,
const WWR4 & b )

◆ mm()

Tensor mm ( const Tensor & a,
const Tensor & b )

Batched matrix-matrix product.

The input matrices a and b must have exactly 2 base dimensions.

◆ mv()

Tensor mv ( const Tensor & a,
const Tensor & v )

Batched matrix-vector product.

The input tensor a must have exactly 2 base dimensions. The input tensor v must have exactly 1 base dimension.

◆ name()

std::string name ( ElasticConstant p)

◆ ne() [1/88]

MillerIndex ne ( const CScalar & a,
const MillerIndex & b )

◆ ne() [2/88]

Quaternion ne ( const CScalar & a,
const Quaternion & b )

◆ ne() [3/88]

R2 ne ( const CScalar & a,
const R2 & b )

◆ ne() [4/88]

R3 ne ( const CScalar & a,
const R3 & b )

◆ ne() [5/88]

R4 ne ( const CScalar & a,
const R4 & b )

◆ ne() [6/88]

Rot ne ( const CScalar & a,
const Rot & b )

◆ ne() [7/88]

Scalar ne ( const CScalar & a,
const Scalar & b )

◆ ne() [8/88]

SFFR4 ne ( const CScalar & a,
const SFFR4 & b )

◆ ne() [9/88]

SFR3 ne ( const CScalar & a,
const SFR3 & b )

◆ ne() [10/88]

SR2 ne ( const CScalar & a,
const SR2 & b )

◆ ne() [11/88]

SSR4 ne ( const CScalar & a,
const SSR4 & b )

◆ ne() [12/88]

SWR4 ne ( const CScalar & a,
const SWR4 & b )

◆ ne() [13/88]

Tensor ne ( const CScalar & a,
const Tensor & b )

◆ ne() [14/88]

Vec ne ( const CScalar & a,
const Vec & b )

◆ ne() [15/88]

WFFR4 ne ( const CScalar & a,
const WFFR4 & b )

◆ ne() [16/88]

WR2 ne ( const CScalar & a,
const WR2 & b )

◆ ne() [17/88]

WSR4 ne ( const CScalar & a,
const WSR4 & b )

◆ ne() [18/88]

WWR4 ne ( const CScalar & a,
const WWR4 & b )

◆ ne() [19/88]

MillerIndex ne ( const MillerIndex & a,
const CScalar & b )

◆ ne() [20/88]

MillerIndex ne ( const MillerIndex & a,
const MillerIndex & b )

◆ ne() [21/88]

MillerIndex ne ( const MillerIndex & a,
const Scalar & b )

◆ ne() [22/88]

Quaternion ne ( const Quaternion & a,
const CScalar & b )

◆ ne() [23/88]

Quaternion ne ( const Quaternion & a,
const Quaternion & b )

◆ ne() [24/88]

Quaternion ne ( const Quaternion & a,
const Scalar & b )

◆ ne() [25/88]

R2 ne ( const R2 & a,
const CScalar & b )

◆ ne() [26/88]

R2 ne ( const R2 & a,
const R2 & b )

◆ ne() [27/88]

R2 ne ( const R2 & a,
const Scalar & b )

◆ ne() [28/88]

R3 ne ( const R3 & a,
const CScalar & b )

◆ ne() [29/88]

R3 ne ( const R3 & a,
const R3 & b )

◆ ne() [30/88]

R3 ne ( const R3 & a,
const Scalar & b )

◆ ne() [31/88]

R4 ne ( const R4 & a,
const CScalar & b )

◆ ne() [32/88]

R4 ne ( const R4 & a,
const R4 & b )

◆ ne() [33/88]

R4 ne ( const R4 & a,
const Scalar & b )

◆ ne() [34/88]

Rot ne ( const Rot & a,
const CScalar & b )

◆ ne() [35/88]

Rot ne ( const Rot & a,
const Rot & b )

◆ ne() [36/88]

Rot ne ( const Rot & a,
const Scalar & b )

◆ ne() [37/88]

Scalar ne ( const Scalar & a,
const CScalar & b )

◆ ne() [38/88]

MillerIndex ne ( const Scalar & a,
const MillerIndex & b )

◆ ne() [39/88]

Quaternion ne ( const Scalar & a,
const Quaternion & b )

◆ ne() [40/88]

R2 ne ( const Scalar & a,
const R2 & b )

◆ ne() [41/88]

R3 ne ( const Scalar & a,
const R3 & b )

◆ ne() [42/88]

R4 ne ( const Scalar & a,
const R4 & b )

◆ ne() [43/88]

Rot ne ( const Scalar & a,
const Rot & b )

◆ ne() [44/88]

Scalar ne ( const Scalar & a,
const Scalar & b )

◆ ne() [45/88]

SFFR4 ne ( const Scalar & a,
const SFFR4 & b )

◆ ne() [46/88]

SFR3 ne ( const Scalar & a,
const SFR3 & b )

◆ ne() [47/88]

SR2 ne ( const Scalar & a,
const SR2 & b )

◆ ne() [48/88]

SSR4 ne ( const Scalar & a,
const SSR4 & b )

◆ ne() [49/88]

SWR4 ne ( const Scalar & a,
const SWR4 & b )

◆ ne() [50/88]

Tensor ne ( const Scalar & a,
const Tensor & b )

◆ ne() [51/88]

Vec ne ( const Scalar & a,
const Vec & b )

◆ ne() [52/88]

WFFR4 ne ( const Scalar & a,
const WFFR4 & b )

◆ ne() [53/88]

WR2 ne ( const Scalar & a,
const WR2 & b )

◆ ne() [54/88]

WSR4 ne ( const Scalar & a,
const WSR4 & b )

◆ ne() [55/88]

WWR4 ne ( const Scalar & a,
const WWR4 & b )

◆ ne() [56/88]

SFFR4 ne ( const SFFR4 & a,
const CScalar & b )

◆ ne() [57/88]

SFFR4 ne ( const SFFR4 & a,
const Scalar & b )

◆ ne() [58/88]

SFFR4 ne ( const SFFR4 & a,
const SFFR4 & b )

◆ ne() [59/88]

SFR3 ne ( const SFR3 & a,
const CScalar & b )

◆ ne() [60/88]

SFR3 ne ( const SFR3 & a,
const Scalar & b )

◆ ne() [61/88]

SFR3 ne ( const SFR3 & a,
const SFR3 & b )

◆ ne() [62/88]

SR2 ne ( const SR2 & a,
const CScalar & b )

◆ ne() [63/88]

SR2 ne ( const SR2 & a,
const Scalar & b )

◆ ne() [64/88]

SR2 ne ( const SR2 & a,
const SR2 & b )

◆ ne() [65/88]

SSR4 ne ( const SSR4 & a,
const CScalar & b )

◆ ne() [66/88]

SSR4 ne ( const SSR4 & a,
const Scalar & b )

◆ ne() [67/88]

SSR4 ne ( const SSR4 & a,
const SSR4 & b )

◆ ne() [68/88]

SWR4 ne ( const SWR4 & a,
const CScalar & b )

◆ ne() [69/88]

SWR4 ne ( const SWR4 & a,
const Scalar & b )

◆ ne() [70/88]

SWR4 ne ( const SWR4 & a,
const SWR4 & b )

◆ ne() [71/88]

Tensor ne ( const Tensor & a,
const CScalar & b )

◆ ne() [72/88]

Tensor ne ( const Tensor & a,
const Scalar & b )

◆ ne() [73/88]

Tensor ne ( const Tensor & a,
const Tensor & b )

◆ ne() [74/88]

Vec ne ( const Vec & a,
const CScalar & b )

◆ ne() [75/88]

Vec ne ( const Vec & a,
const Scalar & b )

◆ ne() [76/88]

Vec ne ( const Vec & a,
const Vec & b )

◆ ne() [77/88]

WFFR4 ne ( const WFFR4 & a,
const CScalar & b )

◆ ne() [78/88]

WFFR4 ne ( const WFFR4 & a,
const Scalar & b )

◆ ne() [79/88]

WFFR4 ne ( const WFFR4 & a,
const WFFR4 & b )

◆ ne() [80/88]

WR2 ne ( const WR2 & a,
const CScalar & b )

◆ ne() [81/88]

WR2 ne ( const WR2 & a,
const Scalar & b )

◆ ne() [82/88]

WR2 ne ( const WR2 & a,
const WR2 & b )

◆ ne() [83/88]

WSR4 ne ( const WSR4 & a,
const CScalar & b )

◆ ne() [84/88]

WSR4 ne ( const WSR4 & a,
const Scalar & b )

◆ ne() [85/88]

WSR4 ne ( const WSR4 & a,
const WSR4 & b )

◆ ne() [86/88]

WWR4 ne ( const WWR4 & a,
const CScalar & b )

◆ ne() [87/88]

WWR4 ne ( const WWR4 & a,
const Scalar & b )

◆ ne() [88/88]

WWR4 ne ( const WWR4 & a,
const WWR4 & b )

◆ neml_assert()

template<typename... Args>
void neml_assert ( bool assertion,
Args &&... args )

◆ neml_assert_base_broadcastable() [1/2]

template<class... T>
void neml_assert_base_broadcastable ( const T &... tensors)

◆ neml_assert_base_broadcastable() [2/2]

template<class... T>
void neml_assert_base_broadcastable ( const T & ...)

Assert that all tensors are base-broadcastable

◆ neml_assert_batch_broadcastable() [1/2]

template<class... T>
void neml_assert_batch_broadcastable ( const T &... tensors)

◆ neml_assert_batch_broadcastable() [2/2]

template<class... T>
void neml_assert_batch_broadcastable ( const T & ...)

Assert that all tensors are batch-broadcastable

◆ neml_assert_broadcastable() [1/2]

template<class... T>
void neml_assert_broadcastable ( const T &... tensors)

◆ neml_assert_broadcastable() [2/2]

template<class... T>
void neml_assert_broadcastable ( const T & ...)

Assert that all tensors are broadcastable

◆ neml_assert_dbg()

template<typename... Args>
void neml_assert_dbg ( bool assertion,
Args &&... args )

◆ neml_assert_dynamic_broadcastable() [1/2]

template<class... T>
void neml_assert_dynamic_broadcastable ( const T &... tensors)

◆ neml_assert_dynamic_broadcastable() [2/2]

template<class... T>
void neml_assert_dynamic_broadcastable ( const T & ...)

Assert that all tensors are dynamic-broadcastable

◆ neml_assert_intmd_broadcastable() [1/2]

template<class... T>
void neml_assert_intmd_broadcastable ( const T &... tensors)

◆ neml_assert_intmd_broadcastable() [2/2]

template<class... T>
void neml_assert_intmd_broadcastable ( const T & ...)

Assert that all tensors are intermediate-broadcastable

◆ neml_assert_not_tracing()

void neml_assert_not_tracing ( )

Assert that we are currently NOT tracing.

◆ neml_assert_not_tracing_dbg()

void neml_assert_not_tracing_dbg ( )

Assert that we are currently NOT tracing (only effective in debug mode).

◆ neml_assert_static_broadcastable() [1/2]

template<class... T>
void neml_assert_static_broadcastable ( const T &... tensors)

◆ neml_assert_static_broadcastable() [2/2]

template<class... T>
void neml_assert_static_broadcastable ( const T & ...)

Assert that all tensors are static-broadcastable

◆ neml_assert_tracing()

void neml_assert_tracing ( )

Assert that we are currently tracing.

◆ neml_assert_tracing_dbg()

void neml_assert_tracing_dbg ( )

Assert that we are currently tracing (only effective in debug mode).

◆ norm() [1/2]

Scalar norm ( const SparseTensorList & )

Norm.

◆ norm() [2/2]

Scalar norm ( const Tensor & a,
const std::optional< CScalar > & eps = std::nullopt )

Frobenius norm of a tensor.

◆ norm_sq() [1/2]

Scalar norm_sq ( const SparseTensorList & )

Norm-squared.

◆ norm_sq() [2/2]

Scalar norm_sq ( const Tensor & a)

Squared Frobenius norm of a tensor.

◆ normalize_gcd() [1/18]

MillerIndex normalize_gcd ( const MillerIndex & a)

◆ normalize_gcd() [2/18]

Quaternion normalize_gcd ( const Quaternion & a)

◆ normalize_gcd() [3/18]

R2 normalize_gcd ( const R2 & a)

◆ normalize_gcd() [4/18]

R3 normalize_gcd ( const R3 & a)

◆ normalize_gcd() [5/18]

R4 normalize_gcd ( const R4 & a)

◆ normalize_gcd() [6/18]

Rot normalize_gcd ( const Rot & a)

◆ normalize_gcd() [7/18]

Scalar normalize_gcd ( const Scalar & a)

◆ normalize_gcd() [8/18]

SFFR4 normalize_gcd ( const SFFR4 & a)

◆ normalize_gcd() [9/18]

SFR3 normalize_gcd ( const SFR3 & a)

◆ normalize_gcd() [10/18]

SR2 normalize_gcd ( const SR2 & a)

◆ normalize_gcd() [11/18]

SSR4 normalize_gcd ( const SSR4 & a)

◆ normalize_gcd() [12/18]

SWR4 normalize_gcd ( const SWR4 & a)

◆ normalize_gcd() [13/18]

Tensor normalize_gcd ( const Tensor & a)

◆ normalize_gcd() [14/18]

Vec normalize_gcd ( const Vec & a)

Normalize a tensor by its greatest common denominator.

Note
If the tensor has only one element, return a tensor of ones of the same shape
If the tensor is not of integer type, it will be converted to the default integer type

◆ normalize_gcd() [15/18]

WFFR4 normalize_gcd ( const WFFR4 & a)

◆ normalize_gcd() [16/18]

WR2 normalize_gcd ( const WR2 & a)

◆ normalize_gcd() [17/18]

WSR4 normalize_gcd ( const WSR4 & a)

◆ normalize_gcd() [18/18]

WWR4 normalize_gcd ( const WWR4 & a)

◆ operator!() [1/18]

MillerIndex operator! ( const MillerIndex & a)

◆ operator!() [2/18]

Quaternion operator! ( const Quaternion & a)

◆ operator!() [3/18]

R2 operator! ( const R2 & a)

◆ operator!() [4/18]

R3 operator! ( const R3 & a)

◆ operator!() [5/18]

R4 operator! ( const R4 & a)

◆ operator!() [6/18]

Rot operator! ( const Rot & a)

◆ operator!() [7/18]

Scalar operator! ( const Scalar & a)

◆ operator!() [8/18]

SFFR4 operator! ( const SFFR4 & a)

◆ operator!() [9/18]

SFR3 operator! ( const SFR3 & a)

◆ operator!() [10/18]

SR2 operator! ( const SR2 & a)

◆ operator!() [11/18]

SSR4 operator! ( const SSR4 & a)

◆ operator!() [12/18]

SWR4 operator! ( const SWR4 & a)

◆ operator!() [13/18]

Tensor operator! ( const Tensor & a)

◆ operator!() [14/18]

Vec operator! ( const Vec & a)

◆ operator!() [15/18]

WFFR4 operator! ( const WFFR4 & a)

◆ operator!() [16/18]

WR2 operator! ( const WR2 & a)

◆ operator!() [17/18]

WSR4 operator! ( const WSR4 & a)

◆ operator!() [18/18]

WWR4 operator! ( const WWR4 & a)

◆ operator!=() [1/93]

MillerIndex operator!= ( const CScalar & a,
const MillerIndex & b )

◆ operator!=() [2/93]

Quaternion operator!= ( const CScalar & a,
const Quaternion & b )

◆ operator!=() [3/93]

R2 operator!= ( const CScalar & a,
const R2 & b )

◆ operator!=() [4/93]

R3 operator!= ( const CScalar & a,
const R3 & b )

◆ operator!=() [5/93]

R4 operator!= ( const CScalar & a,
const R4 & b )

◆ operator!=() [6/93]

Rot operator!= ( const CScalar & a,
const Rot & b )

◆ operator!=() [7/93]

Scalar operator!= ( const CScalar & a,
const Scalar & b )

◆ operator!=() [8/93]

SFFR4 operator!= ( const CScalar & a,
const SFFR4 & b )

◆ operator!=() [9/93]

SFR3 operator!= ( const CScalar & a,
const SFR3 & b )

◆ operator!=() [10/93]

SR2 operator!= ( const CScalar & a,
const SR2 & b )

◆ operator!=() [11/93]

SSR4 operator!= ( const CScalar & a,
const SSR4 & b )

◆ operator!=() [12/93]

SWR4 operator!= ( const CScalar & a,
const SWR4 & b )

◆ operator!=() [13/93]

Tensor operator!= ( const CScalar & a,
const Tensor & b )

◆ operator!=() [14/93]

Vec operator!= ( const CScalar & a,
const Vec & b )

◆ operator!=() [15/93]

WFFR4 operator!= ( const CScalar & a,
const WFFR4 & b )

◆ operator!=() [16/93]

WR2 operator!= ( const CScalar & a,
const WR2 & b )

◆ operator!=() [17/93]

WSR4 operator!= ( const CScalar & a,
const WSR4 & b )

◆ operator!=() [18/93]

WWR4 operator!= ( const CScalar & a,
const WWR4 & b )

◆ operator!=() [19/93]

bool operator!= ( const LabeledAxis & a,
const LabeledAxis & b )

◆ operator!=() [20/93]

bool operator!= ( const LabeledAxisAccessor & a,
const LabeledAxisAccessor & b )

Compare for equality between two LabeledAxisAccessor.

◆ operator!=() [21/93]

MillerIndex operator!= ( const MillerIndex & a,
const CScalar & b )

◆ operator!=() [22/93]

MillerIndex operator!= ( const MillerIndex & a,
const MillerIndex & b )

◆ operator!=() [23/93]

MillerIndex operator!= ( const MillerIndex & a,
const Scalar & b )

◆ operator!=() [24/93]

Quaternion operator!= ( const Quaternion & a,
const CScalar & b )

◆ operator!=() [25/93]

Quaternion operator!= ( const Quaternion & a,
const Quaternion & b )

◆ operator!=() [26/93]

Quaternion operator!= ( const Quaternion & a,
const Scalar & b )

◆ operator!=() [27/93]

R2 operator!= ( const R2 & a,
const CScalar & b )

◆ operator!=() [28/93]

R2 operator!= ( const R2 & a,
const R2 & b )

◆ operator!=() [29/93]

R2 operator!= ( const R2 & a,
const Scalar & b )

◆ operator!=() [30/93]

R3 operator!= ( const R3 & a,
const CScalar & b )

◆ operator!=() [31/93]

R3 operator!= ( const R3 & a,
const R3 & b )

◆ operator!=() [32/93]

R3 operator!= ( const R3 & a,
const Scalar & b )

◆ operator!=() [33/93]

R4 operator!= ( const R4 & a,
const CScalar & b )

◆ operator!=() [34/93]

R4 operator!= ( const R4 & a,
const R4 & b )

◆ operator!=() [35/93]

R4 operator!= ( const R4 & a,
const Scalar & b )

◆ operator!=() [36/93]

Rot operator!= ( const Rot & a,
const CScalar & b )

◆ operator!=() [37/93]

Rot operator!= ( const Rot & a,
const Rot & b )

◆ operator!=() [38/93]

Rot operator!= ( const Rot & a,
const Scalar & b )

◆ operator!=() [39/93]

Scalar operator!= ( const Scalar & a,
const CScalar & b )

◆ operator!=() [40/93]

MillerIndex operator!= ( const Scalar & a,
const MillerIndex & b )

◆ operator!=() [41/93]

Quaternion operator!= ( const Scalar & a,
const Quaternion & b )

◆ operator!=() [42/93]

R2 operator!= ( const Scalar & a,
const R2 & b )

◆ operator!=() [43/93]

R3 operator!= ( const Scalar & a,
const R3 & b )

◆ operator!=() [44/93]

R4 operator!= ( const Scalar & a,
const R4 & b )

◆ operator!=() [45/93]

Rot operator!= ( const Scalar & a,
const Rot & b )

◆ operator!=() [46/93]

Scalar operator!= ( const Scalar & a,
const Scalar & b )

◆ operator!=() [47/93]

SFFR4 operator!= ( const Scalar & a,
const SFFR4 & b )

◆ operator!=() [48/93]

SFR3 operator!= ( const Scalar & a,
const SFR3 & b )

◆ operator!=() [49/93]

SR2 operator!= ( const Scalar & a,
const SR2 & b )

◆ operator!=() [50/93]

SSR4 operator!= ( const Scalar & a,
const SSR4 & b )

◆ operator!=() [51/93]

SWR4 operator!= ( const Scalar & a,
const SWR4 & b )

◆ operator!=() [52/93]

Tensor operator!= ( const Scalar & a,
const Tensor & b )

◆ operator!=() [53/93]

Vec operator!= ( const Scalar & a,
const Vec & b )

◆ operator!=() [54/93]

WFFR4 operator!= ( const Scalar & a,
const WFFR4 & b )

◆ operator!=() [55/93]

WR2 operator!= ( const Scalar & a,
const WR2 & b )

◆ operator!=() [56/93]

WSR4 operator!= ( const Scalar & a,
const WSR4 & b )

◆ operator!=() [57/93]

WWR4 operator!= ( const Scalar & a,
const WWR4 & b )

◆ operator!=() [58/93]

SFFR4 operator!= ( const SFFR4 & a,
const CScalar & b )

◆ operator!=() [59/93]

SFFR4 operator!= ( const SFFR4 & a,
const Scalar & b )

◆ operator!=() [60/93]

SFFR4 operator!= ( const SFFR4 & a,
const SFFR4 & b )

◆ operator!=() [61/93]

SFR3 operator!= ( const SFR3 & a,
const CScalar & b )

◆ operator!=() [62/93]

SFR3 operator!= ( const SFR3 & a,
const Scalar & b )

◆ operator!=() [63/93]

SFR3 operator!= ( const SFR3 & a,
const SFR3 & b )

◆ operator!=() [64/93]

SR2 operator!= ( const SR2 & a,
const CScalar & b )

◆ operator!=() [65/93]

SR2 operator!= ( const SR2 & a,
const Scalar & b )

◆ operator!=() [66/93]

SR2 operator!= ( const SR2 & a,
const SR2 & b )

◆ operator!=() [67/93]

SSR4 operator!= ( const SSR4 & a,
const CScalar & b )

◆ operator!=() [68/93]

SSR4 operator!= ( const SSR4 & a,
const Scalar & b )

◆ operator!=() [69/93]

SSR4 operator!= ( const SSR4 & a,
const SSR4 & b )

◆ operator!=() [70/93]

SWR4 operator!= ( const SWR4 & a,
const CScalar & b )

◆ operator!=() [71/93]

SWR4 operator!= ( const SWR4 & a,
const Scalar & b )

◆ operator!=() [72/93]

SWR4 operator!= ( const SWR4 & a,
const SWR4 & b )

◆ operator!=() [73/93]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator!= ( const T1 & a,
const T2 & b )

◆ operator!=() [74/93]

Tensor operator!= ( const Tensor & a,
const CScalar & b )

◆ operator!=() [75/93]

Tensor operator!= ( const Tensor & a,
const Scalar & b )

◆ operator!=() [76/93]

Tensor operator!= ( const Tensor & a,
const Tensor & b )

◆ operator!=() [77/93]

bool operator!= ( const TraceableSize & lhs,
const TraceableSize & rhs )

◆ operator!=() [78/93]

bool operator!= ( const TraceableTensorShape & lhs,
const TraceableTensorShape & rhs )

◆ operator!=() [79/93]

Vec operator!= ( const Vec & a,
const CScalar & b )

◆ operator!=() [80/93]

Vec operator!= ( const Vec & a,
const Scalar & b )

◆ operator!=() [81/93]

Vec operator!= ( const Vec & a,
const Vec & b )

◆ operator!=() [82/93]

WFFR4 operator!= ( const WFFR4 & a,
const CScalar & b )

◆ operator!=() [83/93]

WFFR4 operator!= ( const WFFR4 & a,
const Scalar & b )

◆ operator!=() [84/93]

WFFR4 operator!= ( const WFFR4 & a,
const WFFR4 & b )

◆ operator!=() [85/93]

WR2 operator!= ( const WR2 & a,
const CScalar & b )

◆ operator!=() [86/93]

WR2 operator!= ( const WR2 & a,
const Scalar & b )

◆ operator!=() [87/93]

WR2 operator!= ( const WR2 & a,
const WR2 & b )

◆ operator!=() [88/93]

WSR4 operator!= ( const WSR4 & a,
const CScalar & b )

◆ operator!=() [89/93]

WSR4 operator!= ( const WSR4 & a,
const Scalar & b )

◆ operator!=() [90/93]

WSR4 operator!= ( const WSR4 & a,
const WSR4 & b )

◆ operator!=() [91/93]

WWR4 operator!= ( const WWR4 & a,
const CScalar & b )

◆ operator!=() [92/93]

WWR4 operator!= ( const WWR4 & a,
const Scalar & b )

◆ operator!=() [93/93]

WWR4 operator!= ( const WWR4 & a,
const WWR4 & b )

◆ operator&&() [1/89]

MillerIndex operator&& ( const CScalar & a,
const MillerIndex & b )

◆ operator&&() [2/89]

Quaternion operator&& ( const CScalar & a,
const Quaternion & b )

◆ operator&&() [3/89]

R2 operator&& ( const CScalar & a,
const R2 & b )

◆ operator&&() [4/89]

R3 operator&& ( const CScalar & a,
const R3 & b )

◆ operator&&() [5/89]

R4 operator&& ( const CScalar & a,
const R4 & b )

◆ operator&&() [6/89]

Rot operator&& ( const CScalar & a,
const Rot & b )

◆ operator&&() [7/89]

Scalar operator&& ( const CScalar & a,
const Scalar & b )

◆ operator&&() [8/89]

SFFR4 operator&& ( const CScalar & a,
const SFFR4 & b )

◆ operator&&() [9/89]

SFR3 operator&& ( const CScalar & a,
const SFR3 & b )

◆ operator&&() [10/89]

SR2 operator&& ( const CScalar & a,
const SR2 & b )

◆ operator&&() [11/89]

SSR4 operator&& ( const CScalar & a,
const SSR4 & b )

◆ operator&&() [12/89]

SWR4 operator&& ( const CScalar & a,
const SWR4 & b )

◆ operator&&() [13/89]

Tensor operator&& ( const CScalar & a,
const Tensor & b )

◆ operator&&() [14/89]

Vec operator&& ( const CScalar & a,
const Vec & b )

◆ operator&&() [15/89]

WFFR4 operator&& ( const CScalar & a,
const WFFR4 & b )

◆ operator&&() [16/89]

WR2 operator&& ( const CScalar & a,
const WR2 & b )

◆ operator&&() [17/89]

WSR4 operator&& ( const CScalar & a,
const WSR4 & b )

◆ operator&&() [18/89]

WWR4 operator&& ( const CScalar & a,
const WWR4 & b )

◆ operator&&() [19/89]

MillerIndex operator&& ( const MillerIndex & a,
const CScalar & b )

◆ operator&&() [20/89]

MillerIndex operator&& ( const MillerIndex & a,
const MillerIndex & b )

◆ operator&&() [21/89]

MillerIndex operator&& ( const MillerIndex & a,
const Scalar & b )

◆ operator&&() [22/89]

Quaternion operator&& ( const Quaternion & a,
const CScalar & b )

◆ operator&&() [23/89]

Quaternion operator&& ( const Quaternion & a,
const Quaternion & b )

◆ operator&&() [24/89]

Quaternion operator&& ( const Quaternion & a,
const Scalar & b )

◆ operator&&() [25/89]

R2 operator&& ( const R2 & a,
const CScalar & b )

◆ operator&&() [26/89]

R2 operator&& ( const R2 & a,
const R2 & b )

◆ operator&&() [27/89]

R2 operator&& ( const R2 & a,
const Scalar & b )

◆ operator&&() [28/89]

R3 operator&& ( const R3 & a,
const CScalar & b )

◆ operator&&() [29/89]

R3 operator&& ( const R3 & a,
const R3 & b )

◆ operator&&() [30/89]

R3 operator&& ( const R3 & a,
const Scalar & b )

◆ operator&&() [31/89]

R4 operator&& ( const R4 & a,
const CScalar & b )

◆ operator&&() [32/89]

R4 operator&& ( const R4 & a,
const R4 & b )

◆ operator&&() [33/89]

R4 operator&& ( const R4 & a,
const Scalar & b )

◆ operator&&() [34/89]

Rot operator&& ( const Rot & a,
const CScalar & b )

◆ operator&&() [35/89]

Rot operator&& ( const Rot & a,
const Rot & b )

◆ operator&&() [36/89]

Rot operator&& ( const Rot & a,
const Scalar & b )

◆ operator&&() [37/89]

Scalar operator&& ( const Scalar & a,
const CScalar & b )

◆ operator&&() [38/89]

MillerIndex operator&& ( const Scalar & a,
const MillerIndex & b )

◆ operator&&() [39/89]

Quaternion operator&& ( const Scalar & a,
const Quaternion & b )

◆ operator&&() [40/89]

R2 operator&& ( const Scalar & a,
const R2 & b )

◆ operator&&() [41/89]

R3 operator&& ( const Scalar & a,
const R3 & b )

◆ operator&&() [42/89]

R4 operator&& ( const Scalar & a,
const R4 & b )

◆ operator&&() [43/89]

Rot operator&& ( const Scalar & a,
const Rot & b )

◆ operator&&() [44/89]

Scalar operator&& ( const Scalar & a,
const Scalar & b )

◆ operator&&() [45/89]

SFFR4 operator&& ( const Scalar & a,
const SFFR4 & b )

◆ operator&&() [46/89]

SFR3 operator&& ( const Scalar & a,
const SFR3 & b )

◆ operator&&() [47/89]

SR2 operator&& ( const Scalar & a,
const SR2 & b )

◆ operator&&() [48/89]

SSR4 operator&& ( const Scalar & a,
const SSR4 & b )

◆ operator&&() [49/89]

SWR4 operator&& ( const Scalar & a,
const SWR4 & b )

◆ operator&&() [50/89]

Tensor operator&& ( const Scalar & a,
const Tensor & b )

◆ operator&&() [51/89]

Vec operator&& ( const Scalar & a,
const Vec & b )

◆ operator&&() [52/89]

WFFR4 operator&& ( const Scalar & a,
const WFFR4 & b )

◆ operator&&() [53/89]

WR2 operator&& ( const Scalar & a,
const WR2 & b )

◆ operator&&() [54/89]

WSR4 operator&& ( const Scalar & a,
const WSR4 & b )

◆ operator&&() [55/89]

WWR4 operator&& ( const Scalar & a,
const WWR4 & b )

◆ operator&&() [56/89]

SFFR4 operator&& ( const SFFR4 & a,
const CScalar & b )

◆ operator&&() [57/89]

SFFR4 operator&& ( const SFFR4 & a,
const Scalar & b )

◆ operator&&() [58/89]

SFFR4 operator&& ( const SFFR4 & a,
const SFFR4 & b )

◆ operator&&() [59/89]

SFR3 operator&& ( const SFR3 & a,
const CScalar & b )

◆ operator&&() [60/89]

SFR3 operator&& ( const SFR3 & a,
const Scalar & b )

◆ operator&&() [61/89]

SFR3 operator&& ( const SFR3 & a,
const SFR3 & b )

◆ operator&&() [62/89]

SR2 operator&& ( const SR2 & a,
const CScalar & b )

◆ operator&&() [63/89]

SR2 operator&& ( const SR2 & a,
const Scalar & b )

◆ operator&&() [64/89]

SR2 operator&& ( const SR2 & a,
const SR2 & b )

◆ operator&&() [65/89]

SSR4 operator&& ( const SSR4 & a,
const CScalar & b )

◆ operator&&() [66/89]

SSR4 operator&& ( const SSR4 & a,
const Scalar & b )

◆ operator&&() [67/89]

SSR4 operator&& ( const SSR4 & a,
const SSR4 & b )

◆ operator&&() [68/89]

SWR4 operator&& ( const SWR4 & a,
const CScalar & b )

◆ operator&&() [69/89]

SWR4 operator&& ( const SWR4 & a,
const Scalar & b )

◆ operator&&() [70/89]

SWR4 operator&& ( const SWR4 & a,
const SWR4 & b )

◆ operator&&() [71/89]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator&& ( const T1 & a,
const T2 & b )

◆ operator&&() [72/89]

Tensor operator&& ( const Tensor & a,
const CScalar & b )

◆ operator&&() [73/89]

Tensor operator&& ( const Tensor & a,
const Scalar & b )

◆ operator&&() [74/89]

Tensor operator&& ( const Tensor & a,
const Tensor & b )

◆ operator&&() [75/89]

Vec operator&& ( const Vec & a,
const CScalar & b )

◆ operator&&() [76/89]

Vec operator&& ( const Vec & a,
const Scalar & b )

◆ operator&&() [77/89]

Vec operator&& ( const Vec & a,
const Vec & b )

◆ operator&&() [78/89]

WFFR4 operator&& ( const WFFR4 & a,
const CScalar & b )

◆ operator&&() [79/89]

WFFR4 operator&& ( const WFFR4 & a,
const Scalar & b )

◆ operator&&() [80/89]

WFFR4 operator&& ( const WFFR4 & a,
const WFFR4 & b )

◆ operator&&() [81/89]

WR2 operator&& ( const WR2 & a,
const CScalar & b )

◆ operator&&() [82/89]

WR2 operator&& ( const WR2 & a,
const Scalar & b )

◆ operator&&() [83/89]

WR2 operator&& ( const WR2 & a,
const WR2 & b )

◆ operator&&() [84/89]

WSR4 operator&& ( const WSR4 & a,
const CScalar & b )

◆ operator&&() [85/89]

WSR4 operator&& ( const WSR4 & a,
const Scalar & b )

◆ operator&&() [86/89]

WSR4 operator&& ( const WSR4 & a,
const WSR4 & b )

◆ operator&&() [87/89]

WWR4 operator&& ( const WWR4 & a,
const CScalar & b )

◆ operator&&() [88/89]

WWR4 operator&& ( const WWR4 & a,
const Scalar & b )

◆ operator&&() [89/89]

WWR4 operator&& ( const WWR4 & a,
const WWR4 & b )

◆ operator*() [1/81]

MillerIndex operator* ( const CScalar & a,
const MillerIndex & b )

◆ operator*() [2/81]

Quaternion operator* ( const CScalar & a,
const Quaternion & b )

◆ operator*() [3/81]

R2 operator* ( const CScalar & a,
const R2 & b )

◆ operator*() [4/81]

R3 operator* ( const CScalar & a,
const R3 & b )

◆ operator*() [5/81]

R4 operator* ( const CScalar & a,
const R4 & b )

◆ operator*() [6/81]

Rot operator* ( const CScalar & a,
const Rot & b )

◆ operator*() [7/81]

Scalar operator* ( const CScalar & a,
const Scalar & b )

◆ operator*() [8/81]

SFFR4 operator* ( const CScalar & a,
const SFFR4 & b )

◆ operator*() [9/81]

SFR3 operator* ( const CScalar & a,
const SFR3 & b )

◆ operator*() [10/81]

SR2 operator* ( const CScalar & a,
const SR2 & b )

◆ operator*() [11/81]

SSR4 operator* ( const CScalar & a,
const SSR4 & b )

◆ operator*() [12/81]

SWR4 operator* ( const CScalar & a,
const SWR4 & b )

◆ operator*() [13/81]

Tensor operator* ( const CScalar & a,
const Tensor & b )

◆ operator*() [14/81]

Vec operator* ( const CScalar & a,
const Vec & b )

◆ operator*() [15/81]

WFFR4 operator* ( const CScalar & a,
const WFFR4 & b )

◆ operator*() [16/81]

WR2 operator* ( const CScalar & a,
const WR2 & b )

◆ operator*() [17/81]

WSR4 operator* ( const CScalar & a,
const WSR4 & b )

◆ operator*() [18/81]

WWR4 operator* ( const CScalar & a,
const WWR4 & b )

◆ operator*() [19/81]

MillerIndex operator* ( const MillerIndex & a,
const CScalar & b )

◆ operator*() [20/81]

MillerIndex operator* ( const MillerIndex & a,
const Scalar & b )

◆ operator*() [21/81]

Quaternion operator* ( const Quaternion & a,
const CScalar & b )

◆ operator*() [22/81]

Quaternion operator* ( const Quaternion & a,
const Scalar & b )

◆ operator*() [23/81]

R2 operator* ( const R2 & ,
const R2 &  )

matrix-matrix product

◆ operator*() [24/81]

Vec operator* ( const R2 & ,
const Vec &  )

matrix-vector product

◆ operator*() [25/81]

R2 operator* ( const R2 & a,
const CScalar & b )

◆ operator*() [26/81]

R2 operator* ( const R2 & a,
const Scalar & b )

◆ operator*() [27/81]

R3 operator* ( const R3 & a,
const CScalar & b )

◆ operator*() [28/81]

R3 operator* ( const R3 & a,
const Scalar & b )

◆ operator*() [29/81]

R4 operator* ( const R4 & a,
const CScalar & b )

◆ operator*() [30/81]

R4 operator* ( const R4 & a,
const Scalar & b )

◆ operator*() [31/81]

Rot operator* ( const Rot & a,
const CScalar & b )

◆ operator*() [32/81]

Rot operator* ( const Rot & a,
const Scalar & b )

◆ operator*() [33/81]

Rot operator* ( const Rot & r1,
const Rot & r2 )

Composition of rotations r3 = r1 * r2 (r2 first, then r1).

◆ operator*() [34/81]

SparseTensorList operator* ( const Scalar & ,
const SparseTensorList &  )

Multiplication with scalar.

◆ operator*() [35/81]

Scalar operator* ( const Scalar & a,
const CScalar & b )

◆ operator*() [36/81]

MillerIndex operator* ( const Scalar & a,
const MillerIndex & b )

◆ operator*() [37/81]

Quaternion operator* ( const Scalar & a,
const Quaternion & b )

◆ operator*() [38/81]

R2 operator* ( const Scalar & a,
const R2 & b )

◆ operator*() [39/81]

R3 operator* ( const Scalar & a,
const R3 & b )

◆ operator*() [40/81]

R4 operator* ( const Scalar & a,
const R4 & b )

◆ operator*() [41/81]

Rot operator* ( const Scalar & a,
const Rot & b )

◆ operator*() [42/81]

Scalar operator* ( const Scalar & a,
const Scalar & b )

◆ operator*() [43/81]

SFFR4 operator* ( const Scalar & a,
const SFFR4 & b )

◆ operator*() [44/81]

SFR3 operator* ( const Scalar & a,
const SFR3 & b )

◆ operator*() [45/81]

SR2 operator* ( const Scalar & a,
const SR2 & b )

◆ operator*() [46/81]

SSR4 operator* ( const Scalar & a,
const SSR4 & b )

◆ operator*() [47/81]

SWR4 operator* ( const Scalar & a,
const SWR4 & b )

◆ operator*() [48/81]

Tensor operator* ( const Scalar & a,
const Tensor & b )

◆ operator*() [49/81]

Vec operator* ( const Scalar & a,
const Vec & b )

◆ operator*() [50/81]

WFFR4 operator* ( const Scalar & a,
const WFFR4 & b )

◆ operator*() [51/81]

WR2 operator* ( const Scalar & a,
const WR2 & b )

◆ operator*() [52/81]

WSR4 operator* ( const Scalar & a,
const WSR4 & b )

◆ operator*() [53/81]

WWR4 operator* ( const Scalar & a,
const WWR4 & b )

◆ operator*() [54/81]

SFFR4 operator* ( const SFFR4 & a,
const CScalar & b )

◆ operator*() [55/81]

SFFR4 operator* ( const SFFR4 & a,
const Scalar & b )

◆ operator*() [56/81]

SFR3 operator* ( const SFR3 & a,
const CScalar & b )

◆ operator*() [57/81]

SFR3 operator* ( const SFR3 & a,
const Scalar & b )

◆ operator*() [58/81]

SparseTensorList operator* ( const SparseTensorList & ,
const Scalar &  )

◆ operator*() [59/81]

SR2 operator* ( const SR2 & a,
const CScalar & b )

◆ operator*() [60/81]

SR2 operator* ( const SR2 & a,
const Scalar & b )

◆ operator*() [61/81]

SSR4 operator* ( const SSR4 & a,
const CScalar & b )

◆ operator*() [62/81]

SSR4 operator* ( const SSR4 & a,
const Scalar & b )

◆ operator*() [63/81]

SR2 operator* ( const SSR4 & a,
const SR2 & b )

◆ operator*() [64/81]

SSR4 operator* ( const SSR4 & a,
const SSR4 & b )

◆ operator*() [65/81]

SWR4 operator* ( const SWR4 & a,
const CScalar & b )

◆ operator*() [66/81]

SWR4 operator* ( const SWR4 & a,
const Scalar & b )

◆ operator*() [67/81]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator* ( const T1 & a,
const T2 & b )

◆ operator*() [68/81]

Tensor operator* ( const Tensor & a,
const CScalar & b )

◆ operator*() [69/81]

Tensor operator* ( const Tensor & a,
const Scalar & b )

◆ operator*() [70/81]

Tensor operator* ( const Tensor & a,
const Tensor & b )

◆ operator*() [71/81]

TraceableSize operator* ( const TraceableSize & lhs,
const TraceableSize & rhs )

Arithmetic operators

◆ operator*() [72/81]

Vec operator* ( const Vec & a,
const CScalar & b )

◆ operator*() [73/81]

Vec operator* ( const Vec & a,
const Scalar & b )

◆ operator*() [74/81]

WFFR4 operator* ( const WFFR4 & a,
const CScalar & b )

◆ operator*() [75/81]

WFFR4 operator* ( const WFFR4 & a,
const Scalar & b )

◆ operator*() [76/81]

WR2 operator* ( const WR2 & a,
const CScalar & b )

◆ operator*() [77/81]

WR2 operator* ( const WR2 & a,
const Scalar & b )

◆ operator*() [78/81]

WSR4 operator* ( const WSR4 & a,
const CScalar & b )

◆ operator*() [79/81]

WSR4 operator* ( const WSR4 & a,
const Scalar & b )

◆ operator*() [80/81]

WWR4 operator* ( const WWR4 & a,
const CScalar & b )

◆ operator*() [81/81]

WWR4 operator* ( const WWR4 & a,
const Scalar & b )

◆ operator*=() [1/18]

MillerIndex & operator*= ( MillerIndex & a,
const CScalar & b )

◆ operator*=() [2/18]

Quaternion & operator*= ( Quaternion & a,
const CScalar & b )

◆ operator*=() [3/18]

R2 & operator*= ( R2 & a,
const CScalar & b )

◆ operator*=() [4/18]

R3 & operator*= ( R3 & a,
const CScalar & b )

◆ operator*=() [5/18]

R4 & operator*= ( R4 & a,
const CScalar & b )

◆ operator*=() [6/18]

Rot & operator*= ( Rot & a,
const CScalar & b )

◆ operator*=() [7/18]

Scalar & operator*= ( Scalar & a,
const CScalar & b )

◆ operator*=() [8/18]

SFFR4 & operator*= ( SFFR4 & a,
const CScalar & b )

◆ operator*=() [9/18]

SFR3 & operator*= ( SFR3 & a,
const CScalar & b )

◆ operator*=() [10/18]

SR2 & operator*= ( SR2 & a,
const CScalar & b )

◆ operator*=() [11/18]

SSR4 & operator*= ( SSR4 & a,
const CScalar & b )

◆ operator*=() [12/18]

SWR4 & operator*= ( SWR4 & a,
const CScalar & b )

◆ operator*=() [13/18]

Tensor & operator*= ( Tensor & a,
const CScalar & b )

◆ operator*=() [14/18]

Vec & operator*= ( Vec & a,
const CScalar & b )

◆ operator*=() [15/18]

WFFR4 & operator*= ( WFFR4 & a,
const CScalar & b )

◆ operator*=() [16/18]

WR2 & operator*= ( WR2 & a,
const CScalar & b )

◆ operator*=() [17/18]

WSR4 & operator*= ( WSR4 & a,
const CScalar & b )

◆ operator*=() [18/18]

WWR4 & operator*= ( WWR4 & a,
const CScalar & b )

◆ operator+() [1/90]

MillerIndex operator+ ( const CScalar & a,
const MillerIndex & b )

◆ operator+() [2/90]

Quaternion operator+ ( const CScalar & a,
const Quaternion & b )

◆ operator+() [3/90]

R2 operator+ ( const CScalar & a,
const R2 & b )

◆ operator+() [4/90]

R3 operator+ ( const CScalar & a,
const R3 & b )

◆ operator+() [5/90]

R4 operator+ ( const CScalar & a,
const R4 & b )

◆ operator+() [6/90]

Rot operator+ ( const CScalar & a,
const Rot & b )

◆ operator+() [7/90]

Scalar operator+ ( const CScalar & a,
const Scalar & b )

◆ operator+() [8/90]

SFFR4 operator+ ( const CScalar & a,
const SFFR4 & b )

◆ operator+() [9/90]

SFR3 operator+ ( const CScalar & a,
const SFR3 & b )

◆ operator+() [10/90]

SR2 operator+ ( const CScalar & a,
const SR2 & b )

◆ operator+() [11/90]

SSR4 operator+ ( const CScalar & a,
const SSR4 & b )

◆ operator+() [12/90]

SWR4 operator+ ( const CScalar & a,
const SWR4 & b )

◆ operator+() [13/90]

Tensor operator+ ( const CScalar & a,
const Tensor & b )

◆ operator+() [14/90]

Vec operator+ ( const CScalar & a,
const Vec & b )

◆ operator+() [15/90]

WFFR4 operator+ ( const CScalar & a,
const WFFR4 & b )

◆ operator+() [16/90]

WR2 operator+ ( const CScalar & a,
const WR2 & b )

◆ operator+() [17/90]

WSR4 operator+ ( const CScalar & a,
const WSR4 & b )

◆ operator+() [18/90]

WWR4 operator+ ( const CScalar & a,
const WWR4 & b )

◆ operator+() [19/90]

MillerIndex operator+ ( const MillerIndex & a,
const CScalar & b )

◆ operator+() [20/90]

MillerIndex operator+ ( const MillerIndex & a,
const MillerIndex & b )

◆ operator+() [21/90]

MillerIndex operator+ ( const MillerIndex & a,
const Scalar & b )

◆ operator+() [22/90]

Quaternion operator+ ( const Quaternion & a,
const CScalar & b )

◆ operator+() [23/90]

Quaternion operator+ ( const Quaternion & a,
const Quaternion & b )

◆ operator+() [24/90]

Quaternion operator+ ( const Quaternion & a,
const Scalar & b )

◆ operator+() [25/90]

R2 operator+ ( const R2 & a,
const CScalar & b )

◆ operator+() [26/90]

R2 operator+ ( const R2 & a,
const R2 & b )

◆ operator+() [27/90]

R2 operator+ ( const R2 & a,
const Scalar & b )

◆ operator+() [28/90]

R3 operator+ ( const R3 & a,
const CScalar & b )

◆ operator+() [29/90]

R3 operator+ ( const R3 & a,
const R3 & b )

◆ operator+() [30/90]

R3 operator+ ( const R3 & a,
const Scalar & b )

◆ operator+() [31/90]

R4 operator+ ( const R4 & a,
const CScalar & b )

◆ operator+() [32/90]

R4 operator+ ( const R4 & a,
const R4 & b )

◆ operator+() [33/90]

R4 operator+ ( const R4 & a,
const Scalar & b )

◆ operator+() [34/90]

Rot operator+ ( const Rot & a,
const CScalar & b )

◆ operator+() [35/90]

Rot operator+ ( const Rot & a,
const Rot & b )

◆ operator+() [36/90]

Rot operator+ ( const Rot & a,
const Scalar & b )

◆ operator+() [37/90]

Scalar operator+ ( const Scalar & a,
const CScalar & b )

◆ operator+() [38/90]

MillerIndex operator+ ( const Scalar & a,
const MillerIndex & b )

◆ operator+() [39/90]

Quaternion operator+ ( const Scalar & a,
const Quaternion & b )

◆ operator+() [40/90]

R2 operator+ ( const Scalar & a,
const R2 & b )

◆ operator+() [41/90]

R3 operator+ ( const Scalar & a,
const R3 & b )

◆ operator+() [42/90]

R4 operator+ ( const Scalar & a,
const R4 & b )

◆ operator+() [43/90]

Rot operator+ ( const Scalar & a,
const Rot & b )

◆ operator+() [44/90]

Scalar operator+ ( const Scalar & a,
const Scalar & b )

◆ operator+() [45/90]

SFFR4 operator+ ( const Scalar & a,
const SFFR4 & b )

◆ operator+() [46/90]

SFR3 operator+ ( const Scalar & a,
const SFR3 & b )

◆ operator+() [47/90]

SR2 operator+ ( const Scalar & a,
const SR2 & b )

◆ operator+() [48/90]

SSR4 operator+ ( const Scalar & a,
const SSR4 & b )

◆ operator+() [49/90]

SWR4 operator+ ( const Scalar & a,
const SWR4 & b )

◆ operator+() [50/90]

Tensor operator+ ( const Scalar & a,
const Tensor & b )

◆ operator+() [51/90]

Vec operator+ ( const Scalar & a,
const Vec & b )

◆ operator+() [52/90]

WFFR4 operator+ ( const Scalar & a,
const WFFR4 & b )

◆ operator+() [53/90]

WR2 operator+ ( const Scalar & a,
const WR2 & b )

◆ operator+() [54/90]

WSR4 operator+ ( const Scalar & a,
const WSR4 & b )

◆ operator+() [55/90]

WWR4 operator+ ( const Scalar & a,
const WWR4 & b )

◆ operator+() [56/90]

SFFR4 operator+ ( const SFFR4 & a,
const CScalar & b )

◆ operator+() [57/90]

SFFR4 operator+ ( const SFFR4 & a,
const Scalar & b )

◆ operator+() [58/90]

SFFR4 operator+ ( const SFFR4 & a,
const SFFR4 & b )

◆ operator+() [59/90]

SFR3 operator+ ( const SFR3 & a,
const CScalar & b )

◆ operator+() [60/90]

SFR3 operator+ ( const SFR3 & a,
const Scalar & b )

◆ operator+() [61/90]

SFR3 operator+ ( const SFR3 & a,
const SFR3 & b )

◆ operator+() [62/90]

SparseTensorList operator+ ( const SparseTensorList & ,
const SparseTensorList &  )

Binary addition.

◆ operator+() [63/90]

SR2 operator+ ( const SR2 & a,
const CScalar & b )

◆ operator+() [64/90]

SR2 operator+ ( const SR2 & a,
const Scalar & b )

◆ operator+() [65/90]

SR2 operator+ ( const SR2 & a,
const SR2 & b )

◆ operator+() [66/90]

SSR4 operator+ ( const SSR4 & a,
const CScalar & b )

◆ operator+() [67/90]

SSR4 operator+ ( const SSR4 & a,
const Scalar & b )

◆ operator+() [68/90]

SSR4 operator+ ( const SSR4 & a,
const SSR4 & b )

◆ operator+() [69/90]

SWR4 operator+ ( const SWR4 & a,
const CScalar & b )

◆ operator+() [70/90]

SWR4 operator+ ( const SWR4 & a,
const Scalar & b )

◆ operator+() [71/90]

SWR4 operator+ ( const SWR4 & a,
const SWR4 & b )

◆ operator+() [72/90]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator+ ( const T1 & a,
const T2 & b )

◆ operator+() [73/90]

Tensor operator+ ( const Tensor & a,
const CScalar & b )

◆ operator+() [74/90]

Tensor operator+ ( const Tensor & a,
const Scalar & b )

◆ operator+() [75/90]

Tensor operator+ ( const Tensor & a,
const Tensor & b )

◆ operator+() [76/90]

Vec operator+ ( const Vec & a,
const CScalar & b )

◆ operator+() [77/90]

Vec operator+ ( const Vec & a,
const Scalar & b )

◆ operator+() [78/90]

Vec operator+ ( const Vec & a,
const Vec & b )

◆ operator+() [79/90]

WFFR4 operator+ ( const WFFR4 & a,
const CScalar & b )

◆ operator+() [80/90]

WFFR4 operator+ ( const WFFR4 & a,
const Scalar & b )

◆ operator+() [81/90]

WFFR4 operator+ ( const WFFR4 & a,
const WFFR4 & b )

◆ operator+() [82/90]

WR2 operator+ ( const WR2 & a,
const CScalar & b )

◆ operator+() [83/90]

WR2 operator+ ( const WR2 & a,
const Scalar & b )

◆ operator+() [84/90]

WR2 operator+ ( const WR2 & a,
const WR2 & b )

◆ operator+() [85/90]

WSR4 operator+ ( const WSR4 & a,
const CScalar & b )

◆ operator+() [86/90]

WSR4 operator+ ( const WSR4 & a,
const Scalar & b )

◆ operator+() [87/90]

WSR4 operator+ ( const WSR4 & a,
const WSR4 & b )

◆ operator+() [88/90]

WWR4 operator+ ( const WWR4 & a,
const CScalar & b )

◆ operator+() [89/90]

WWR4 operator+ ( const WWR4 & a,
const Scalar & b )

◆ operator+() [90/90]

WWR4 operator+ ( const WWR4 & a,
const WWR4 & b )

◆ operator+=() [1/18]

MillerIndex & operator+= ( MillerIndex & a,
const CScalar & b )

◆ operator+=() [2/18]

Quaternion & operator+= ( Quaternion & a,
const CScalar & b )

◆ operator+=() [3/18]

R2 & operator+= ( R2 & a,
const CScalar & b )

◆ operator+=() [4/18]

R3 & operator+= ( R3 & a,
const CScalar & b )

◆ operator+=() [5/18]

R4 & operator+= ( R4 & a,
const CScalar & b )

◆ operator+=() [6/18]

Rot & operator+= ( Rot & a,
const CScalar & b )

◆ operator+=() [7/18]

Scalar & operator+= ( Scalar & a,
const CScalar & b )

◆ operator+=() [8/18]

SFFR4 & operator+= ( SFFR4 & a,
const CScalar & b )

◆ operator+=() [9/18]

SFR3 & operator+= ( SFR3 & a,
const CScalar & b )

◆ operator+=() [10/18]

SR2 & operator+= ( SR2 & a,
const CScalar & b )

◆ operator+=() [11/18]

SSR4 & operator+= ( SSR4 & a,
const CScalar & b )

◆ operator+=() [12/18]

SWR4 & operator+= ( SWR4 & a,
const CScalar & b )

◆ operator+=() [13/18]

Tensor & operator+= ( Tensor & a,
const CScalar & b )

◆ operator+=() [14/18]

Vec & operator+= ( Vec & a,
const CScalar & b )

◆ operator+=() [15/18]

WFFR4 & operator+= ( WFFR4 & a,
const CScalar & b )

◆ operator+=() [16/18]

WR2 & operator+= ( WR2 & a,
const CScalar & b )

◆ operator+=() [17/18]

WSR4 & operator+= ( WSR4 & a,
const CScalar & b )

◆ operator+=() [18/18]

WWR4 & operator+= ( WWR4 & a,
const CScalar & b )

◆ operator-() [1/90]

MillerIndex operator- ( const CScalar & a,
const MillerIndex & b )

◆ operator-() [2/90]

Quaternion operator- ( const CScalar & a,
const Quaternion & b )

◆ operator-() [3/90]

R2 operator- ( const CScalar & a,
const R2 & b )

◆ operator-() [4/90]

R3 operator- ( const CScalar & a,
const R3 & b )

◆ operator-() [5/90]

R4 operator- ( const CScalar & a,
const R4 & b )

◆ operator-() [6/90]

Rot operator- ( const CScalar & a,
const Rot & b )

◆ operator-() [7/90]

Scalar operator- ( const CScalar & a,
const Scalar & b )

◆ operator-() [8/90]

SFFR4 operator- ( const CScalar & a,
const SFFR4 & b )

◆ operator-() [9/90]

SFR3 operator- ( const CScalar & a,
const SFR3 & b )

◆ operator-() [10/90]

SR2 operator- ( const CScalar & a,
const SR2 & b )

◆ operator-() [11/90]

SSR4 operator- ( const CScalar & a,
const SSR4 & b )

◆ operator-() [12/90]

SWR4 operator- ( const CScalar & a,
const SWR4 & b )

◆ operator-() [13/90]

Tensor operator- ( const CScalar & a,
const Tensor & b )

◆ operator-() [14/90]

Vec operator- ( const CScalar & a,
const Vec & b )

◆ operator-() [15/90]

WFFR4 operator- ( const CScalar & a,
const WFFR4 & b )

◆ operator-() [16/90]

WR2 operator- ( const CScalar & a,
const WR2 & b )

◆ operator-() [17/90]

WSR4 operator- ( const CScalar & a,
const WSR4 & b )

◆ operator-() [18/90]

WWR4 operator- ( const CScalar & a,
const WWR4 & b )

◆ operator-() [19/90]

MillerIndex operator- ( const MillerIndex & a,
const CScalar & b )

◆ operator-() [20/90]

MillerIndex operator- ( const MillerIndex & a,
const MillerIndex & b )

◆ operator-() [21/90]

MillerIndex operator- ( const MillerIndex & a,
const Scalar & b )

◆ operator-() [22/90]

Quaternion operator- ( const Quaternion & a,
const CScalar & b )

◆ operator-() [23/90]

Quaternion operator- ( const Quaternion & a,
const Quaternion & b )

◆ operator-() [24/90]

Quaternion operator- ( const Quaternion & a,
const Scalar & b )

◆ operator-() [25/90]

R2 operator- ( const R2 & a,
const CScalar & b )

◆ operator-() [26/90]

R2 operator- ( const R2 & a,
const R2 & b )

◆ operator-() [27/90]

R2 operator- ( const R2 & a,
const Scalar & b )

◆ operator-() [28/90]

R3 operator- ( const R3 & a,
const CScalar & b )

◆ operator-() [29/90]

R3 operator- ( const R3 & a,
const R3 & b )

◆ operator-() [30/90]

R3 operator- ( const R3 & a,
const Scalar & b )

◆ operator-() [31/90]

R4 operator- ( const R4 & a,
const CScalar & b )

◆ operator-() [32/90]

R4 operator- ( const R4 & a,
const R4 & b )

◆ operator-() [33/90]

R4 operator- ( const R4 & a,
const Scalar & b )

◆ operator-() [34/90]

Rot operator- ( const Rot & a,
const CScalar & b )

◆ operator-() [35/90]

Rot operator- ( const Rot & a,
const Rot & b )

◆ operator-() [36/90]

Rot operator- ( const Rot & a,
const Scalar & b )

◆ operator-() [37/90]

Scalar operator- ( const Scalar & a,
const CScalar & b )

◆ operator-() [38/90]

MillerIndex operator- ( const Scalar & a,
const MillerIndex & b )

◆ operator-() [39/90]

Quaternion operator- ( const Scalar & a,
const Quaternion & b )

◆ operator-() [40/90]

R2 operator- ( const Scalar & a,
const R2 & b )

◆ operator-() [41/90]

R3 operator- ( const Scalar & a,
const R3 & b )

◆ operator-() [42/90]

R4 operator- ( const Scalar & a,
const R4 & b )

◆ operator-() [43/90]

Rot operator- ( const Scalar & a,
const Rot & b )

◆ operator-() [44/90]

Scalar operator- ( const Scalar & a,
const Scalar & b )

◆ operator-() [45/90]

SFFR4 operator- ( const Scalar & a,
const SFFR4 & b )

◆ operator-() [46/90]

SFR3 operator- ( const Scalar & a,
const SFR3 & b )

◆ operator-() [47/90]

SR2 operator- ( const Scalar & a,
const SR2 & b )

◆ operator-() [48/90]

SSR4 operator- ( const Scalar & a,
const SSR4 & b )

◆ operator-() [49/90]

SWR4 operator- ( const Scalar & a,
const SWR4 & b )

◆ operator-() [50/90]

Tensor operator- ( const Scalar & a,
const Tensor & b )

◆ operator-() [51/90]

Vec operator- ( const Scalar & a,
const Vec & b )

◆ operator-() [52/90]

WFFR4 operator- ( const Scalar & a,
const WFFR4 & b )

◆ operator-() [53/90]

WR2 operator- ( const Scalar & a,
const WR2 & b )

◆ operator-() [54/90]

WSR4 operator- ( const Scalar & a,
const WSR4 & b )

◆ operator-() [55/90]

WWR4 operator- ( const Scalar & a,
const WWR4 & b )

◆ operator-() [56/90]

SFFR4 operator- ( const SFFR4 & a,
const CScalar & b )

◆ operator-() [57/90]

SFFR4 operator- ( const SFFR4 & a,
const Scalar & b )

◆ operator-() [58/90]

SFFR4 operator- ( const SFFR4 & a,
const SFFR4 & b )

◆ operator-() [59/90]

SFR3 operator- ( const SFR3 & a,
const CScalar & b )

◆ operator-() [60/90]

SFR3 operator- ( const SFR3 & a,
const Scalar & b )

◆ operator-() [61/90]

SFR3 operator- ( const SFR3 & a,
const SFR3 & b )

◆ operator-() [62/90]

SparseTensorList operator- ( const SparseTensorList & )

Unary negation

◆ operator-() [63/90]

SR2 operator- ( const SR2 & a,
const CScalar & b )

◆ operator-() [64/90]

SR2 operator- ( const SR2 & a,
const Scalar & b )

◆ operator-() [65/90]

SR2 operator- ( const SR2 & a,
const SR2 & b )

◆ operator-() [66/90]

SSR4 operator- ( const SSR4 & a,
const CScalar & b )

◆ operator-() [67/90]

SSR4 operator- ( const SSR4 & a,
const Scalar & b )

◆ operator-() [68/90]

SSR4 operator- ( const SSR4 & a,
const SSR4 & b )

◆ operator-() [69/90]

SWR4 operator- ( const SWR4 & a,
const CScalar & b )

◆ operator-() [70/90]

SWR4 operator- ( const SWR4 & a,
const Scalar & b )

◆ operator-() [71/90]

SWR4 operator- ( const SWR4 & a,
const SWR4 & b )

◆ operator-() [72/90]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator- ( const T1 & a,
const T2 & b )

◆ operator-() [73/90]

Tensor operator- ( const Tensor & a,
const CScalar & b )

◆ operator-() [74/90]

Tensor operator- ( const Tensor & a,
const Scalar & b )

◆ operator-() [75/90]

Tensor operator- ( const Tensor & a,
const Tensor & b )

◆ operator-() [76/90]

Vec operator- ( const Vec & a,
const CScalar & b )

◆ operator-() [77/90]

Vec operator- ( const Vec & a,
const Scalar & b )

◆ operator-() [78/90]

Vec operator- ( const Vec & a,
const Vec & b )

◆ operator-() [79/90]

WFFR4 operator- ( const WFFR4 & a,
const CScalar & b )

◆ operator-() [80/90]

WFFR4 operator- ( const WFFR4 & a,
const Scalar & b )

◆ operator-() [81/90]

WFFR4 operator- ( const WFFR4 & a,
const WFFR4 & b )

◆ operator-() [82/90]

WR2 operator- ( const WR2 & a,
const CScalar & b )

◆ operator-() [83/90]

WR2 operator- ( const WR2 & a,
const Scalar & b )

◆ operator-() [84/90]

WR2 operator- ( const WR2 & a,
const WR2 & b )

◆ operator-() [85/90]

WSR4 operator- ( const WSR4 & a,
const CScalar & b )

◆ operator-() [86/90]

WSR4 operator- ( const WSR4 & a,
const Scalar & b )

◆ operator-() [87/90]

WSR4 operator- ( const WSR4 & a,
const WSR4 & b )

◆ operator-() [88/90]

WWR4 operator- ( const WWR4 & a,
const CScalar & b )

◆ operator-() [89/90]

WWR4 operator- ( const WWR4 & a,
const Scalar & b )

◆ operator-() [90/90]

WWR4 operator- ( const WWR4 & a,
const WWR4 & b )

◆ operator-=() [1/18]

MillerIndex & operator-= ( MillerIndex & a,
const CScalar & b )

◆ operator-=() [2/18]

Quaternion & operator-= ( Quaternion & a,
const CScalar & b )

◆ operator-=() [3/18]

R2 & operator-= ( R2 & a,
const CScalar & b )

◆ operator-=() [4/18]

R3 & operator-= ( R3 & a,
const CScalar & b )

◆ operator-=() [5/18]

R4 & operator-= ( R4 & a,
const CScalar & b )

◆ operator-=() [6/18]

Rot & operator-= ( Rot & a,
const CScalar & b )

◆ operator-=() [7/18]

Scalar & operator-= ( Scalar & a,
const CScalar & b )

◆ operator-=() [8/18]

SFFR4 & operator-= ( SFFR4 & a,
const CScalar & b )

◆ operator-=() [9/18]

SFR3 & operator-= ( SFR3 & a,
const CScalar & b )

◆ operator-=() [10/18]

SR2 & operator-= ( SR2 & a,
const CScalar & b )

◆ operator-=() [11/18]

SSR4 & operator-= ( SSR4 & a,
const CScalar & b )

◆ operator-=() [12/18]

SWR4 & operator-= ( SWR4 & a,
const CScalar & b )

◆ operator-=() [13/18]

Tensor & operator-= ( Tensor & a,
const CScalar & b )

◆ operator-=() [14/18]

Vec & operator-= ( Vec & a,
const CScalar & b )

◆ operator-=() [15/18]

WFFR4 & operator-= ( WFFR4 & a,
const CScalar & b )

◆ operator-=() [16/18]

WR2 & operator-= ( WR2 & a,
const CScalar & b )

◆ operator-=() [17/18]

WSR4 & operator-= ( WSR4 & a,
const CScalar & b )

◆ operator-=() [18/18]

WWR4 & operator-= ( WWR4 & a,
const CScalar & b )

◆ operator/() [1/73]

MillerIndex operator/ ( const CScalar & a,
const MillerIndex & b )

◆ operator/() [2/73]

Quaternion operator/ ( const CScalar & a,
const Quaternion & b )

◆ operator/() [3/73]

R2 operator/ ( const CScalar & a,
const R2 & b )

◆ operator/() [4/73]

R3 operator/ ( const CScalar & a,
const R3 & b )

◆ operator/() [5/73]

R4 operator/ ( const CScalar & a,
const R4 & b )

◆ operator/() [6/73]

Rot operator/ ( const CScalar & a,
const Rot & b )

◆ operator/() [7/73]

Scalar operator/ ( const CScalar & a,
const Scalar & b )

◆ operator/() [8/73]

SFFR4 operator/ ( const CScalar & a,
const SFFR4 & b )

◆ operator/() [9/73]

SFR3 operator/ ( const CScalar & a,
const SFR3 & b )

◆ operator/() [10/73]

SR2 operator/ ( const CScalar & a,
const SR2 & b )

◆ operator/() [11/73]

SSR4 operator/ ( const CScalar & a,
const SSR4 & b )

◆ operator/() [12/73]

SWR4 operator/ ( const CScalar & a,
const SWR4 & b )

◆ operator/() [13/73]

Tensor operator/ ( const CScalar & a,
const Tensor & b )

◆ operator/() [14/73]

Vec operator/ ( const CScalar & a,
const Vec & b )

◆ operator/() [15/73]

WFFR4 operator/ ( const CScalar & a,
const WFFR4 & b )

◆ operator/() [16/73]

WR2 operator/ ( const CScalar & a,
const WR2 & b )

◆ operator/() [17/73]

WSR4 operator/ ( const CScalar & a,
const WSR4 & b )

◆ operator/() [18/73]

WWR4 operator/ ( const CScalar & a,
const WWR4 & b )

◆ operator/() [19/73]

MillerIndex operator/ ( const MillerIndex & a,
const CScalar & b )

◆ operator/() [20/73]

MillerIndex operator/ ( const MillerIndex & a,
const Scalar & b )

◆ operator/() [21/73]

Quaternion operator/ ( const Quaternion & a,
const CScalar & b )

◆ operator/() [22/73]

Quaternion operator/ ( const Quaternion & a,
const Scalar & b )

◆ operator/() [23/73]

R2 operator/ ( const R2 & a,
const CScalar & b )

◆ operator/() [24/73]

R2 operator/ ( const R2 & a,
const Scalar & b )

◆ operator/() [25/73]

R3 operator/ ( const R3 & a,
const CScalar & b )

◆ operator/() [26/73]

R3 operator/ ( const R3 & a,
const Scalar & b )

◆ operator/() [27/73]

R4 operator/ ( const R4 & a,
const CScalar & b )

◆ operator/() [28/73]

R4 operator/ ( const R4 & a,
const Scalar & b )

◆ operator/() [29/73]

Rot operator/ ( const Rot & a,
const CScalar & b )

◆ operator/() [30/73]

Rot operator/ ( const Rot & a,
const Scalar & b )

◆ operator/() [31/73]

Scalar operator/ ( const Scalar & a,
const CScalar & b )

◆ operator/() [32/73]

MillerIndex operator/ ( const Scalar & a,
const MillerIndex & b )

◆ operator/() [33/73]

Quaternion operator/ ( const Scalar & a,
const Quaternion & b )

◆ operator/() [34/73]

R2 operator/ ( const Scalar & a,
const R2 & b )

◆ operator/() [35/73]

R3 operator/ ( const Scalar & a,
const R3 & b )

◆ operator/() [36/73]

R4 operator/ ( const Scalar & a,
const R4 & b )

◆ operator/() [37/73]

Rot operator/ ( const Scalar & a,
const Rot & b )

◆ operator/() [38/73]

Scalar operator/ ( const Scalar & a,
const Scalar & b )

◆ operator/() [39/73]

SFFR4 operator/ ( const Scalar & a,
const SFFR4 & b )

◆ operator/() [40/73]

SFR3 operator/ ( const Scalar & a,
const SFR3 & b )

◆ operator/() [41/73]

SR2 operator/ ( const Scalar & a,
const SR2 & b )

◆ operator/() [42/73]

SSR4 operator/ ( const Scalar & a,
const SSR4 & b )

◆ operator/() [43/73]

SWR4 operator/ ( const Scalar & a,
const SWR4 & b )

◆ operator/() [44/73]

Tensor operator/ ( const Scalar & a,
const Tensor & b )

◆ operator/() [45/73]

Vec operator/ ( const Scalar & a,
const Vec & b )

◆ operator/() [46/73]

WFFR4 operator/ ( const Scalar & a,
const WFFR4 & b )

◆ operator/() [47/73]

WR2 operator/ ( const Scalar & a,
const WR2 & b )

◆ operator/() [48/73]

WSR4 operator/ ( const Scalar & a,
const WSR4 & b )

◆ operator/() [49/73]

WWR4 operator/ ( const Scalar & a,
const WWR4 & b )

◆ operator/() [50/73]

SFFR4 operator/ ( const SFFR4 & a,
const CScalar & b )

◆ operator/() [51/73]

SFFR4 operator/ ( const SFFR4 & a,
const Scalar & b )

◆ operator/() [52/73]

SFR3 operator/ ( const SFR3 & a,
const CScalar & b )

◆ operator/() [53/73]

SFR3 operator/ ( const SFR3 & a,
const Scalar & b )

◆ operator/() [54/73]

SR2 operator/ ( const SR2 & a,
const CScalar & b )

◆ operator/() [55/73]

SR2 operator/ ( const SR2 & a,
const Scalar & b )

◆ operator/() [56/73]

SSR4 operator/ ( const SSR4 & a,
const CScalar & b )

◆ operator/() [57/73]

SSR4 operator/ ( const SSR4 & a,
const Scalar & b )

◆ operator/() [58/73]

SWR4 operator/ ( const SWR4 & a,
const CScalar & b )

◆ operator/() [59/73]

SWR4 operator/ ( const SWR4 & a,
const Scalar & b )

◆ operator/() [60/73]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator/ ( const T1 & a,
const T2 & b )

◆ operator/() [61/73]

Tensor operator/ ( const Tensor & a,
const CScalar & b )

◆ operator/() [62/73]

Tensor operator/ ( const Tensor & a,
const Scalar & b )

◆ operator/() [63/73]

Tensor operator/ ( const Tensor & a,
const Tensor & b )

◆ operator/() [64/73]

Vec operator/ ( const Vec & a,
const CScalar & b )

◆ operator/() [65/73]

Vec operator/ ( const Vec & a,
const Scalar & b )

◆ operator/() [66/73]

WFFR4 operator/ ( const WFFR4 & a,
const CScalar & b )

◆ operator/() [67/73]

WFFR4 operator/ ( const WFFR4 & a,
const Scalar & b )

◆ operator/() [68/73]

WR2 operator/ ( const WR2 & a,
const CScalar & b )

◆ operator/() [69/73]

WR2 operator/ ( const WR2 & a,
const Scalar & b )

◆ operator/() [70/73]

WSR4 operator/ ( const WSR4 & a,
const CScalar & b )

◆ operator/() [71/73]

WSR4 operator/ ( const WSR4 & a,
const Scalar & b )

◆ operator/() [72/73]

WWR4 operator/ ( const WWR4 & a,
const CScalar & b )

◆ operator/() [73/73]

WWR4 operator/ ( const WWR4 & a,
const Scalar & b )

◆ operator/=() [1/18]

MillerIndex & operator/= ( MillerIndex & a,
const CScalar & b )

◆ operator/=() [2/18]

Quaternion & operator/= ( Quaternion & a,
const CScalar & b )

◆ operator/=() [3/18]

R2 & operator/= ( R2 & a,
const CScalar & b )

◆ operator/=() [4/18]

R3 & operator/= ( R3 & a,
const CScalar & b )

◆ operator/=() [5/18]

R4 & operator/= ( R4 & a,
const CScalar & b )

◆ operator/=() [6/18]

Rot & operator/= ( Rot & a,
const CScalar & b )

◆ operator/=() [7/18]

Scalar & operator/= ( Scalar & a,
const CScalar & b )

◆ operator/=() [8/18]

SFFR4 & operator/= ( SFFR4 & a,
const CScalar & b )

◆ operator/=() [9/18]

SFR3 & operator/= ( SFR3 & a,
const CScalar & b )

◆ operator/=() [10/18]

SR2 & operator/= ( SR2 & a,
const CScalar & b )

◆ operator/=() [11/18]

SSR4 & operator/= ( SSR4 & a,
const CScalar & b )

◆ operator/=() [12/18]

SWR4 & operator/= ( SWR4 & a,
const CScalar & b )

◆ operator/=() [13/18]

Tensor & operator/= ( Tensor & a,
const CScalar & b )

◆ operator/=() [14/18]

Vec & operator/= ( Vec & a,
const CScalar & b )

◆ operator/=() [15/18]

WFFR4 & operator/= ( WFFR4 & a,
const CScalar & b )

◆ operator/=() [16/18]

WR2 & operator/= ( WR2 & a,
const CScalar & b )

◆ operator/=() [17/18]

WSR4 & operator/= ( WSR4 & a,
const CScalar & b )

◆ operator/=() [18/18]

WWR4 & operator/= ( WWR4 & a,
const CScalar & b )

◆ operator<() [1/90]

MillerIndex operator< ( const CScalar & a,
const MillerIndex & b )

◆ operator<() [2/90]

Quaternion operator< ( const CScalar & a,
const Quaternion & b )

◆ operator<() [3/90]

R2 operator< ( const CScalar & a,
const R2 & b )

◆ operator<() [4/90]

R3 operator< ( const CScalar & a,
const R3 & b )

◆ operator<() [5/90]

R4 operator< ( const CScalar & a,
const R4 & b )

◆ operator<() [6/90]

Rot operator< ( const CScalar & a,
const Rot & b )

◆ operator<() [7/90]

Scalar operator< ( const CScalar & a,
const Scalar & b )

◆ operator<() [8/90]

SFFR4 operator< ( const CScalar & a,
const SFFR4 & b )

◆ operator<() [9/90]

SFR3 operator< ( const CScalar & a,
const SFR3 & b )

◆ operator<() [10/90]

SR2 operator< ( const CScalar & a,
const SR2 & b )

◆ operator<() [11/90]

SSR4 operator< ( const CScalar & a,
const SSR4 & b )

◆ operator<() [12/90]

SWR4 operator< ( const CScalar & a,
const SWR4 & b )

◆ operator<() [13/90]

Tensor operator< ( const CScalar & a,
const Tensor & b )

◆ operator<() [14/90]

Vec operator< ( const CScalar & a,
const Vec & b )

◆ operator<() [15/90]

WFFR4 operator< ( const CScalar & a,
const WFFR4 & b )

◆ operator<() [16/90]

WR2 operator< ( const CScalar & a,
const WR2 & b )

◆ operator<() [17/90]

WSR4 operator< ( const CScalar & a,
const WSR4 & b )

◆ operator<() [18/90]

WWR4 operator< ( const CScalar & a,
const WWR4 & b )

◆ operator<() [19/90]

bool operator< ( const LabeledAxisAccessor & a,
const LabeledAxisAccessor & b )

The (strict) smaller than operator is created so as to use LabeledAxisAccessor in sorted data structures.

◆ operator<() [20/90]

MillerIndex operator< ( const MillerIndex & a,
const CScalar & b )

◆ operator<() [21/90]

MillerIndex operator< ( const MillerIndex & a,
const MillerIndex & b )

◆ operator<() [22/90]

MillerIndex operator< ( const MillerIndex & a,
const Scalar & b )

◆ operator<() [23/90]

Quaternion operator< ( const Quaternion & a,
const CScalar & b )

◆ operator<() [24/90]

Quaternion operator< ( const Quaternion & a,
const Quaternion & b )

◆ operator<() [25/90]

Quaternion operator< ( const Quaternion & a,
const Scalar & b )

◆ operator<() [26/90]

R2 operator< ( const R2 & a,
const CScalar & b )

◆ operator<() [27/90]

R2 operator< ( const R2 & a,
const R2 & b )

◆ operator<() [28/90]

R2 operator< ( const R2 & a,
const Scalar & b )

◆ operator<() [29/90]

R3 operator< ( const R3 & a,
const CScalar & b )

◆ operator<() [30/90]

R3 operator< ( const R3 & a,
const R3 & b )

◆ operator<() [31/90]

R3 operator< ( const R3 & a,
const Scalar & b )

◆ operator<() [32/90]

R4 operator< ( const R4 & a,
const CScalar & b )

◆ operator<() [33/90]

R4 operator< ( const R4 & a,
const R4 & b )

◆ operator<() [34/90]

R4 operator< ( const R4 & a,
const Scalar & b )

◆ operator<() [35/90]

Rot operator< ( const Rot & a,
const CScalar & b )

◆ operator<() [36/90]

Rot operator< ( const Rot & a,
const Rot & b )

◆ operator<() [37/90]

Rot operator< ( const Rot & a,
const Scalar & b )

◆ operator<() [38/90]

Scalar operator< ( const Scalar & a,
const CScalar & b )

◆ operator<() [39/90]

MillerIndex operator< ( const Scalar & a,
const MillerIndex & b )

◆ operator<() [40/90]

Quaternion operator< ( const Scalar & a,
const Quaternion & b )

◆ operator<() [41/90]

R2 operator< ( const Scalar & a,
const R2 & b )

◆ operator<() [42/90]

R3 operator< ( const Scalar & a,
const R3 & b )

◆ operator<() [43/90]

R4 operator< ( const Scalar & a,
const R4 & b )

◆ operator<() [44/90]

Rot operator< ( const Scalar & a,
const Rot & b )

◆ operator<() [45/90]

Scalar operator< ( const Scalar & a,
const Scalar & b )

◆ operator<() [46/90]

SFFR4 operator< ( const Scalar & a,
const SFFR4 & b )

◆ operator<() [47/90]

SFR3 operator< ( const Scalar & a,
const SFR3 & b )

◆ operator<() [48/90]

SR2 operator< ( const Scalar & a,
const SR2 & b )

◆ operator<() [49/90]

SSR4 operator< ( const Scalar & a,
const SSR4 & b )

◆ operator<() [50/90]

SWR4 operator< ( const Scalar & a,
const SWR4 & b )

◆ operator<() [51/90]

Tensor operator< ( const Scalar & a,
const Tensor & b )

◆ operator<() [52/90]

Vec operator< ( const Scalar & a,
const Vec & b )

◆ operator<() [53/90]

WFFR4 operator< ( const Scalar & a,
const WFFR4 & b )

◆ operator<() [54/90]

WR2 operator< ( const Scalar & a,
const WR2 & b )

◆ operator<() [55/90]

WSR4 operator< ( const Scalar & a,
const WSR4 & b )

◆ operator<() [56/90]

WWR4 operator< ( const Scalar & a,
const WWR4 & b )

◆ operator<() [57/90]

SFFR4 operator< ( const SFFR4 & a,
const CScalar & b )

◆ operator<() [58/90]

SFFR4 operator< ( const SFFR4 & a,
const Scalar & b )

◆ operator<() [59/90]

SFFR4 operator< ( const SFFR4 & a,
const SFFR4 & b )

◆ operator<() [60/90]

SFR3 operator< ( const SFR3 & a,
const CScalar & b )

◆ operator<() [61/90]

SFR3 operator< ( const SFR3 & a,
const Scalar & b )

◆ operator<() [62/90]

SFR3 operator< ( const SFR3 & a,
const SFR3 & b )

◆ operator<() [63/90]

SR2 operator< ( const SR2 & a,
const CScalar & b )

◆ operator<() [64/90]

SR2 operator< ( const SR2 & a,
const Scalar & b )

◆ operator<() [65/90]

SR2 operator< ( const SR2 & a,
const SR2 & b )

◆ operator<() [66/90]

SSR4 operator< ( const SSR4 & a,
const CScalar & b )

◆ operator<() [67/90]

SSR4 operator< ( const SSR4 & a,
const Scalar & b )

◆ operator<() [68/90]

SSR4 operator< ( const SSR4 & a,
const SSR4 & b )

◆ operator<() [69/90]

SWR4 operator< ( const SWR4 & a,
const CScalar & b )

◆ operator<() [70/90]

SWR4 operator< ( const SWR4 & a,
const Scalar & b )

◆ operator<() [71/90]

SWR4 operator< ( const SWR4 & a,
const SWR4 & b )

◆ operator<() [72/90]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator< ( const T1 & a,
const T2 & b )

◆ operator<() [73/90]

Tensor operator< ( const Tensor & a,
const CScalar & b )

◆ operator<() [74/90]

Tensor operator< ( const Tensor & a,
const Scalar & b )

◆ operator<() [75/90]

Tensor operator< ( const Tensor & a,
const Tensor & b )

◆ operator<() [76/90]

Vec operator< ( const Vec & a,
const CScalar & b )

◆ operator<() [77/90]

Vec operator< ( const Vec & a,
const Scalar & b )

◆ operator<() [78/90]

Vec operator< ( const Vec & a,
const Vec & b )

◆ operator<() [79/90]

WFFR4 operator< ( const WFFR4 & a,
const CScalar & b )

◆ operator<() [80/90]

WFFR4 operator< ( const WFFR4 & a,
const Scalar & b )

◆ operator<() [81/90]

WFFR4 operator< ( const WFFR4 & a,
const WFFR4 & b )

◆ operator<() [82/90]

WR2 operator< ( const WR2 & a,
const CScalar & b )

◆ operator<() [83/90]

WR2 operator< ( const WR2 & a,
const Scalar & b )

◆ operator<() [84/90]

WR2 operator< ( const WR2 & a,
const WR2 & b )

◆ operator<() [85/90]

WSR4 operator< ( const WSR4 & a,
const CScalar & b )

◆ operator<() [86/90]

WSR4 operator< ( const WSR4 & a,
const Scalar & b )

◆ operator<() [87/90]

WSR4 operator< ( const WSR4 & a,
const WSR4 & b )

◆ operator<() [88/90]

WWR4 operator< ( const WWR4 & a,
const CScalar & b )

◆ operator<() [89/90]

WWR4 operator< ( const WWR4 & a,
const Scalar & b )

◆ operator<() [90/90]

WWR4 operator< ( const WWR4 & a,
const WWR4 & b )

◆ operator<<() [1/12]

std::ostream & operator<< ( std::ostream & ,
const EnumSelection &  )

◆ operator<<() [2/12]

std::ostream & operator<< ( std::ostream & ,
const MultiEnumSelection &  )

◆ operator<<() [3/12]

std::ostream & operator<< ( std::ostream & ,
const OptionBase &  )

◆ operator<<() [4/12]

std::ostream & operator<< ( std::ostream & os,
const InputFile & p )

◆ operator<<() [5/12]

std::ostream & operator<< ( std::ostream & os,
const LabeledAxis & axis )

◆ operator<<() [6/12]

std::ostream & operator<< ( std::ostream & os,
const LabeledAxisAccessor & accessor )

Serialize the accessor into a string. The format is simply the concatenation of all the item names delimited by "/".

◆ operator<<() [7/12]

std::ostream & operator<< ( std::ostream & os,
const Model & model )

◆ operator<<() [8/12]

std::ostream & operator<< ( std::ostream & os,
const OptionSet & p )

◆ operator<<() [9/12]

template<typename T>
std::ostream & operator<< ( std::ostream & os,
const TensorName< T > & t )

Stream out a TensorName (used for printing OptionSet).

◆ operator<<() [10/12]

std::ostream & operator<< ( std::ostream & os,
const TensorType & t )

◆ operator<<() [11/12]

std::ostream & operator<< ( std::ostream & os,
const TraceableSize & s )

Streaming operator.

◆ operator<<() [12/12]

std::ostream & operator<< ( std::ostream & os,
FType f )

◆ operator<=() [1/89]

MillerIndex operator<= ( const CScalar & a,
const MillerIndex & b )

◆ operator<=() [2/89]

Quaternion operator<= ( const CScalar & a,
const Quaternion & b )

◆ operator<=() [3/89]

R2 operator<= ( const CScalar & a,
const R2 & b )

◆ operator<=() [4/89]

R3 operator<= ( const CScalar & a,
const R3 & b )

◆ operator<=() [5/89]

R4 operator<= ( const CScalar & a,
const R4 & b )

◆ operator<=() [6/89]

Rot operator<= ( const CScalar & a,
const Rot & b )

◆ operator<=() [7/89]

Scalar operator<= ( const CScalar & a,
const Scalar & b )

◆ operator<=() [8/89]

SFFR4 operator<= ( const CScalar & a,
const SFFR4 & b )

◆ operator<=() [9/89]

SFR3 operator<= ( const CScalar & a,
const SFR3 & b )

◆ operator<=() [10/89]

SR2 operator<= ( const CScalar & a,
const SR2 & b )

◆ operator<=() [11/89]

SSR4 operator<= ( const CScalar & a,
const SSR4 & b )

◆ operator<=() [12/89]

SWR4 operator<= ( const CScalar & a,
const SWR4 & b )

◆ operator<=() [13/89]

Tensor operator<= ( const CScalar & a,
const Tensor & b )

◆ operator<=() [14/89]

Vec operator<= ( const CScalar & a,
const Vec & b )

◆ operator<=() [15/89]

WFFR4 operator<= ( const CScalar & a,
const WFFR4 & b )

◆ operator<=() [16/89]

WR2 operator<= ( const CScalar & a,
const WR2 & b )

◆ operator<=() [17/89]

WSR4 operator<= ( const CScalar & a,
const WSR4 & b )

◆ operator<=() [18/89]

WWR4 operator<= ( const CScalar & a,
const WWR4 & b )

◆ operator<=() [19/89]

MillerIndex operator<= ( const MillerIndex & a,
const CScalar & b )

◆ operator<=() [20/89]

MillerIndex operator<= ( const MillerIndex & a,
const MillerIndex & b )

◆ operator<=() [21/89]

MillerIndex operator<= ( const MillerIndex & a,
const Scalar & b )

◆ operator<=() [22/89]

Quaternion operator<= ( const Quaternion & a,
const CScalar & b )

◆ operator<=() [23/89]

Quaternion operator<= ( const Quaternion & a,
const Quaternion & b )

◆ operator<=() [24/89]

Quaternion operator<= ( const Quaternion & a,
const Scalar & b )

◆ operator<=() [25/89]

R2 operator<= ( const R2 & a,
const CScalar & b )

◆ operator<=() [26/89]

R2 operator<= ( const R2 & a,
const R2 & b )

◆ operator<=() [27/89]

R2 operator<= ( const R2 & a,
const Scalar & b )

◆ operator<=() [28/89]

R3 operator<= ( const R3 & a,
const CScalar & b )

◆ operator<=() [29/89]

R3 operator<= ( const R3 & a,
const R3 & b )

◆ operator<=() [30/89]

R3 operator<= ( const R3 & a,
const Scalar & b )

◆ operator<=() [31/89]

R4 operator<= ( const R4 & a,
const CScalar & b )

◆ operator<=() [32/89]

R4 operator<= ( const R4 & a,
const R4 & b )

◆ operator<=() [33/89]

R4 operator<= ( const R4 & a,
const Scalar & b )

◆ operator<=() [34/89]

Rot operator<= ( const Rot & a,
const CScalar & b )

◆ operator<=() [35/89]

Rot operator<= ( const Rot & a,
const Rot & b )

◆ operator<=() [36/89]

Rot operator<= ( const Rot & a,
const Scalar & b )

◆ operator<=() [37/89]

Scalar operator<= ( const Scalar & a,
const CScalar & b )

◆ operator<=() [38/89]

MillerIndex operator<= ( const Scalar & a,
const MillerIndex & b )

◆ operator<=() [39/89]

Quaternion operator<= ( const Scalar & a,
const Quaternion & b )

◆ operator<=() [40/89]

R2 operator<= ( const Scalar & a,
const R2 & b )

◆ operator<=() [41/89]

R3 operator<= ( const Scalar & a,
const R3 & b )

◆ operator<=() [42/89]

R4 operator<= ( const Scalar & a,
const R4 & b )

◆ operator<=() [43/89]

Rot operator<= ( const Scalar & a,
const Rot & b )

◆ operator<=() [44/89]

Scalar operator<= ( const Scalar & a,
const Scalar & b )

◆ operator<=() [45/89]

SFFR4 operator<= ( const Scalar & a,
const SFFR4 & b )

◆ operator<=() [46/89]

SFR3 operator<= ( const Scalar & a,
const SFR3 & b )

◆ operator<=() [47/89]

SR2 operator<= ( const Scalar & a,
const SR2 & b )

◆ operator<=() [48/89]

SSR4 operator<= ( const Scalar & a,
const SSR4 & b )

◆ operator<=() [49/89]

SWR4 operator<= ( const Scalar & a,
const SWR4 & b )

◆ operator<=() [50/89]

Tensor operator<= ( const Scalar & a,
const Tensor & b )

◆ operator<=() [51/89]

Vec operator<= ( const Scalar & a,
const Vec & b )

◆ operator<=() [52/89]

WFFR4 operator<= ( const Scalar & a,
const WFFR4 & b )

◆ operator<=() [53/89]

WR2 operator<= ( const Scalar & a,
const WR2 & b )

◆ operator<=() [54/89]

WSR4 operator<= ( const Scalar & a,
const WSR4 & b )

◆ operator<=() [55/89]

WWR4 operator<= ( const Scalar & a,
const WWR4 & b )

◆ operator<=() [56/89]

SFFR4 operator<= ( const SFFR4 & a,
const CScalar & b )

◆ operator<=() [57/89]

SFFR4 operator<= ( const SFFR4 & a,
const Scalar & b )

◆ operator<=() [58/89]

SFFR4 operator<= ( const SFFR4 & a,
const SFFR4 & b )

◆ operator<=() [59/89]

SFR3 operator<= ( const SFR3 & a,
const CScalar & b )

◆ operator<=() [60/89]

SFR3 operator<= ( const SFR3 & a,
const Scalar & b )

◆ operator<=() [61/89]

SFR3 operator<= ( const SFR3 & a,
const SFR3 & b )

◆ operator<=() [62/89]

SR2 operator<= ( const SR2 & a,
const CScalar & b )

◆ operator<=() [63/89]

SR2 operator<= ( const SR2 & a,
const Scalar & b )

◆ operator<=() [64/89]

SR2 operator<= ( const SR2 & a,
const SR2 & b )

◆ operator<=() [65/89]

SSR4 operator<= ( const SSR4 & a,
const CScalar & b )

◆ operator<=() [66/89]

SSR4 operator<= ( const SSR4 & a,
const Scalar & b )

◆ operator<=() [67/89]

SSR4 operator<= ( const SSR4 & a,
const SSR4 & b )

◆ operator<=() [68/89]

SWR4 operator<= ( const SWR4 & a,
const CScalar & b )

◆ operator<=() [69/89]

SWR4 operator<= ( const SWR4 & a,
const Scalar & b )

◆ operator<=() [70/89]

SWR4 operator<= ( const SWR4 & a,
const SWR4 & b )

◆ operator<=() [71/89]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator<= ( const T1 & a,
const T2 & b )

◆ operator<=() [72/89]

Tensor operator<= ( const Tensor & a,
const CScalar & b )

◆ operator<=() [73/89]

Tensor operator<= ( const Tensor & a,
const Scalar & b )

◆ operator<=() [74/89]

Tensor operator<= ( const Tensor & a,
const Tensor & b )

◆ operator<=() [75/89]

Vec operator<= ( const Vec & a,
const CScalar & b )

◆ operator<=() [76/89]

Vec operator<= ( const Vec & a,
const Scalar & b )

◆ operator<=() [77/89]

Vec operator<= ( const Vec & a,
const Vec & b )

◆ operator<=() [78/89]

WFFR4 operator<= ( const WFFR4 & a,
const CScalar & b )

◆ operator<=() [79/89]

WFFR4 operator<= ( const WFFR4 & a,
const Scalar & b )

◆ operator<=() [80/89]

WFFR4 operator<= ( const WFFR4 & a,
const WFFR4 & b )

◆ operator<=() [81/89]

WR2 operator<= ( const WR2 & a,
const CScalar & b )

◆ operator<=() [82/89]

WR2 operator<= ( const WR2 & a,
const Scalar & b )

◆ operator<=() [83/89]

WR2 operator<= ( const WR2 & a,
const WR2 & b )

◆ operator<=() [84/89]

WSR4 operator<= ( const WSR4 & a,
const CScalar & b )

◆ operator<=() [85/89]

WSR4 operator<= ( const WSR4 & a,
const Scalar & b )

◆ operator<=() [86/89]

WSR4 operator<= ( const WSR4 & a,
const WSR4 & b )

◆ operator<=() [87/89]

WWR4 operator<= ( const WWR4 & a,
const CScalar & b )

◆ operator<=() [88/89]

WWR4 operator<= ( const WWR4 & a,
const Scalar & b )

◆ operator<=() [89/89]

WWR4 operator<= ( const WWR4 & a,
const WWR4 & b )

◆ operator==() [1/93]

MillerIndex operator== ( const CScalar & a,
const MillerIndex & b )

◆ operator==() [2/93]

Quaternion operator== ( const CScalar & a,
const Quaternion & b )

◆ operator==() [3/93]

R2 operator== ( const CScalar & a,
const R2 & b )

◆ operator==() [4/93]

R3 operator== ( const CScalar & a,
const R3 & b )

◆ operator==() [5/93]

R4 operator== ( const CScalar & a,
const R4 & b )

◆ operator==() [6/93]

Rot operator== ( const CScalar & a,
const Rot & b )

◆ operator==() [7/93]

Scalar operator== ( const CScalar & a,
const Scalar & b )

◆ operator==() [8/93]

SFFR4 operator== ( const CScalar & a,
const SFFR4 & b )

◆ operator==() [9/93]

SFR3 operator== ( const CScalar & a,
const SFR3 & b )

◆ operator==() [10/93]

SR2 operator== ( const CScalar & a,
const SR2 & b )

◆ operator==() [11/93]

SSR4 operator== ( const CScalar & a,
const SSR4 & b )

◆ operator==() [12/93]

SWR4 operator== ( const CScalar & a,
const SWR4 & b )

◆ operator==() [13/93]

Tensor operator== ( const CScalar & a,
const Tensor & b )

◆ operator==() [14/93]

Vec operator== ( const CScalar & a,
const Vec & b )

◆ operator==() [15/93]

WFFR4 operator== ( const CScalar & a,
const WFFR4 & b )

◆ operator==() [16/93]

WR2 operator== ( const CScalar & a,
const WR2 & b )

◆ operator==() [17/93]

WSR4 operator== ( const CScalar & a,
const WSR4 & b )

◆ operator==() [18/93]

WWR4 operator== ( const CScalar & a,
const WWR4 & b )

◆ operator==() [19/93]

bool operator== ( const LabeledAxis & a,
const LabeledAxis & b )

◆ operator==() [20/93]

bool operator== ( const LabeledAxisAccessor & a,
const LabeledAxisAccessor & b )

Compare for equality between two LabeledAxisAccessor.

◆ operator==() [21/93]

MillerIndex operator== ( const MillerIndex & a,
const CScalar & b )

◆ operator==() [22/93]

MillerIndex operator== ( const MillerIndex & a,
const MillerIndex & b )

◆ operator==() [23/93]

MillerIndex operator== ( const MillerIndex & a,
const Scalar & b )

◆ operator==() [24/93]

Quaternion operator== ( const Quaternion & a,
const CScalar & b )

◆ operator==() [25/93]

Quaternion operator== ( const Quaternion & a,
const Quaternion & b )

◆ operator==() [26/93]

Quaternion operator== ( const Quaternion & a,
const Scalar & b )

◆ operator==() [27/93]

R2 operator== ( const R2 & a,
const CScalar & b )

◆ operator==() [28/93]

R2 operator== ( const R2 & a,
const R2 & b )

◆ operator==() [29/93]

R2 operator== ( const R2 & a,
const Scalar & b )

◆ operator==() [30/93]

R3 operator== ( const R3 & a,
const CScalar & b )

◆ operator==() [31/93]

R3 operator== ( const R3 & a,
const R3 & b )

◆ operator==() [32/93]

R3 operator== ( const R3 & a,
const Scalar & b )

◆ operator==() [33/93]

R4 operator== ( const R4 & a,
const CScalar & b )

◆ operator==() [34/93]

R4 operator== ( const R4 & a,
const R4 & b )

◆ operator==() [35/93]

R4 operator== ( const R4 & a,
const Scalar & b )

◆ operator==() [36/93]

Rot operator== ( const Rot & a,
const CScalar & b )

◆ operator==() [37/93]

Rot operator== ( const Rot & a,
const Rot & b )

◆ operator==() [38/93]

Rot operator== ( const Rot & a,
const Scalar & b )

◆ operator==() [39/93]

Scalar operator== ( const Scalar & a,
const CScalar & b )

◆ operator==() [40/93]

MillerIndex operator== ( const Scalar & a,
const MillerIndex & b )

◆ operator==() [41/93]

Quaternion operator== ( const Scalar & a,
const Quaternion & b )

◆ operator==() [42/93]

R2 operator== ( const Scalar & a,
const R2 & b )

◆ operator==() [43/93]

R3 operator== ( const Scalar & a,
const R3 & b )

◆ operator==() [44/93]

R4 operator== ( const Scalar & a,
const R4 & b )

◆ operator==() [45/93]

Rot operator== ( const Scalar & a,
const Rot & b )

◆ operator==() [46/93]

Scalar operator== ( const Scalar & a,
const Scalar & b )

◆ operator==() [47/93]

SFFR4 operator== ( const Scalar & a,
const SFFR4 & b )

◆ operator==() [48/93]

SFR3 operator== ( const Scalar & a,
const SFR3 & b )

◆ operator==() [49/93]

SR2 operator== ( const Scalar & a,
const SR2 & b )

◆ operator==() [50/93]

SSR4 operator== ( const Scalar & a,
const SSR4 & b )

◆ operator==() [51/93]

SWR4 operator== ( const Scalar & a,
const SWR4 & b )

◆ operator==() [52/93]

Tensor operator== ( const Scalar & a,
const Tensor & b )

◆ operator==() [53/93]

Vec operator== ( const Scalar & a,
const Vec & b )

◆ operator==() [54/93]

WFFR4 operator== ( const Scalar & a,
const WFFR4 & b )

◆ operator==() [55/93]

WR2 operator== ( const Scalar & a,
const WR2 & b )

◆ operator==() [56/93]

WSR4 operator== ( const Scalar & a,
const WSR4 & b )

◆ operator==() [57/93]

WWR4 operator== ( const Scalar & a,
const WWR4 & b )

◆ operator==() [58/93]

SFFR4 operator== ( const SFFR4 & a,
const CScalar & b )

◆ operator==() [59/93]

SFFR4 operator== ( const SFFR4 & a,
const Scalar & b )

◆ operator==() [60/93]

SFFR4 operator== ( const SFFR4 & a,
const SFFR4 & b )

◆ operator==() [61/93]

SFR3 operator== ( const SFR3 & a,
const CScalar & b )

◆ operator==() [62/93]

SFR3 operator== ( const SFR3 & a,
const Scalar & b )

◆ operator==() [63/93]

SFR3 operator== ( const SFR3 & a,
const SFR3 & b )

◆ operator==() [64/93]

SR2 operator== ( const SR2 & a,
const CScalar & b )

◆ operator==() [65/93]

SR2 operator== ( const SR2 & a,
const Scalar & b )

◆ operator==() [66/93]

SR2 operator== ( const SR2 & a,
const SR2 & b )

◆ operator==() [67/93]

SSR4 operator== ( const SSR4 & a,
const CScalar & b )

◆ operator==() [68/93]

SSR4 operator== ( const SSR4 & a,
const Scalar & b )

◆ operator==() [69/93]

SSR4 operator== ( const SSR4 & a,
const SSR4 & b )

◆ operator==() [70/93]

SWR4 operator== ( const SWR4 & a,
const CScalar & b )

◆ operator==() [71/93]

SWR4 operator== ( const SWR4 & a,
const Scalar & b )

◆ operator==() [72/93]

SWR4 operator== ( const SWR4 & a,
const SWR4 & b )

◆ operator==() [73/93]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator== ( const T1 & a,
const T2 & b )

◆ operator==() [74/93]

Tensor operator== ( const Tensor & a,
const CScalar & b )

◆ operator==() [75/93]

Tensor operator== ( const Tensor & a,
const Scalar & b )

◆ operator==() [76/93]

Tensor operator== ( const Tensor & a,
const Tensor & b )

◆ operator==() [77/93]

bool operator== ( const TraceableSize & lhs,
const TraceableSize & rhs )

Comparison operators

◆ operator==() [78/93]

bool operator== ( const TraceableTensorShape & lhs,
const TraceableTensorShape & rhs )

Comparison operators

◆ operator==() [79/93]

Vec operator== ( const Vec & a,
const CScalar & b )

◆ operator==() [80/93]

Vec operator== ( const Vec & a,
const Scalar & b )

◆ operator==() [81/93]

Vec operator== ( const Vec & a,
const Vec & b )

◆ operator==() [82/93]

WFFR4 operator== ( const WFFR4 & a,
const CScalar & b )

◆ operator==() [83/93]

WFFR4 operator== ( const WFFR4 & a,
const Scalar & b )

◆ operator==() [84/93]

WFFR4 operator== ( const WFFR4 & a,
const WFFR4 & b )

◆ operator==() [85/93]

WR2 operator== ( const WR2 & a,
const CScalar & b )

◆ operator==() [86/93]

WR2 operator== ( const WR2 & a,
const Scalar & b )

◆ operator==() [87/93]

WR2 operator== ( const WR2 & a,
const WR2 & b )

◆ operator==() [88/93]

WSR4 operator== ( const WSR4 & a,
const CScalar & b )

◆ operator==() [89/93]

WSR4 operator== ( const WSR4 & a,
const Scalar & b )

◆ operator==() [90/93]

WSR4 operator== ( const WSR4 & a,
const WSR4 & b )

◆ operator==() [91/93]

WWR4 operator== ( const WWR4 & a,
const CScalar & b )

◆ operator==() [92/93]

WWR4 operator== ( const WWR4 & a,
const Scalar & b )

◆ operator==() [93/93]

WWR4 operator== ( const WWR4 & a,
const WWR4 & b )

◆ operator>() [1/89]

MillerIndex operator> ( const CScalar & a,
const MillerIndex & b )

◆ operator>() [2/89]

Quaternion operator> ( const CScalar & a,
const Quaternion & b )

◆ operator>() [3/89]

R2 operator> ( const CScalar & a,
const R2 & b )

◆ operator>() [4/89]

R3 operator> ( const CScalar & a,
const R3 & b )

◆ operator>() [5/89]

R4 operator> ( const CScalar & a,
const R4 & b )

◆ operator>() [6/89]

Rot operator> ( const CScalar & a,
const Rot & b )

◆ operator>() [7/89]

Scalar operator> ( const CScalar & a,
const Scalar & b )

◆ operator>() [8/89]

SFFR4 operator> ( const CScalar & a,
const SFFR4 & b )

◆ operator>() [9/89]

SFR3 operator> ( const CScalar & a,
const SFR3 & b )

◆ operator>() [10/89]

SR2 operator> ( const CScalar & a,
const SR2 & b )

◆ operator>() [11/89]

SSR4 operator> ( const CScalar & a,
const SSR4 & b )

◆ operator>() [12/89]

SWR4 operator> ( const CScalar & a,
const SWR4 & b )

◆ operator>() [13/89]

Tensor operator> ( const CScalar & a,
const Tensor & b )

◆ operator>() [14/89]

Vec operator> ( const CScalar & a,
const Vec & b )

◆ operator>() [15/89]

WFFR4 operator> ( const CScalar & a,
const WFFR4 & b )

◆ operator>() [16/89]

WR2 operator> ( const CScalar & a,
const WR2 & b )

◆ operator>() [17/89]

WSR4 operator> ( const CScalar & a,
const WSR4 & b )

◆ operator>() [18/89]

WWR4 operator> ( const CScalar & a,
const WWR4 & b )

◆ operator>() [19/89]

MillerIndex operator> ( const MillerIndex & a,
const CScalar & b )

◆ operator>() [20/89]

MillerIndex operator> ( const MillerIndex & a,
const MillerIndex & b )

◆ operator>() [21/89]

MillerIndex operator> ( const MillerIndex & a,
const Scalar & b )

◆ operator>() [22/89]

Quaternion operator> ( const Quaternion & a,
const CScalar & b )

◆ operator>() [23/89]

Quaternion operator> ( const Quaternion & a,
const Quaternion & b )

◆ operator>() [24/89]

Quaternion operator> ( const Quaternion & a,
const Scalar & b )

◆ operator>() [25/89]

R2 operator> ( const R2 & a,
const CScalar & b )

◆ operator>() [26/89]

R2 operator> ( const R2 & a,
const R2 & b )

◆ operator>() [27/89]

R2 operator> ( const R2 & a,
const Scalar & b )

◆ operator>() [28/89]

R3 operator> ( const R3 & a,
const CScalar & b )

◆ operator>() [29/89]

R3 operator> ( const R3 & a,
const R3 & b )

◆ operator>() [30/89]

R3 operator> ( const R3 & a,
const Scalar & b )

◆ operator>() [31/89]

R4 operator> ( const R4 & a,
const CScalar & b )

◆ operator>() [32/89]

R4 operator> ( const R4 & a,
const R4 & b )

◆ operator>() [33/89]

R4 operator> ( const R4 & a,
const Scalar & b )

◆ operator>() [34/89]

Rot operator> ( const Rot & a,
const CScalar & b )

◆ operator>() [35/89]

Rot operator> ( const Rot & a,
const Rot & b )

◆ operator>() [36/89]

Rot operator> ( const Rot & a,
const Scalar & b )

◆ operator>() [37/89]

Scalar operator> ( const Scalar & a,
const CScalar & b )

◆ operator>() [38/89]

MillerIndex operator> ( const Scalar & a,
const MillerIndex & b )

◆ operator>() [39/89]

Quaternion operator> ( const Scalar & a,
const Quaternion & b )

◆ operator>() [40/89]

R2 operator> ( const Scalar & a,
const R2 & b )

◆ operator>() [41/89]

R3 operator> ( const Scalar & a,
const R3 & b )

◆ operator>() [42/89]

R4 operator> ( const Scalar & a,
const R4 & b )

◆ operator>() [43/89]

Rot operator> ( const Scalar & a,
const Rot & b )

◆ operator>() [44/89]

Scalar operator> ( const Scalar & a,
const Scalar & b )

◆ operator>() [45/89]

SFFR4 operator> ( const Scalar & a,
const SFFR4 & b )

◆ operator>() [46/89]

SFR3 operator> ( const Scalar & a,
const SFR3 & b )

◆ operator>() [47/89]

SR2 operator> ( const Scalar & a,
const SR2 & b )

◆ operator>() [48/89]

SSR4 operator> ( const Scalar & a,
const SSR4 & b )

◆ operator>() [49/89]

SWR4 operator> ( const Scalar & a,
const SWR4 & b )

◆ operator>() [50/89]

Tensor operator> ( const Scalar & a,
const Tensor & b )

◆ operator>() [51/89]

Vec operator> ( const Scalar & a,
const Vec & b )

◆ operator>() [52/89]

WFFR4 operator> ( const Scalar & a,
const WFFR4 & b )

◆ operator>() [53/89]

WR2 operator> ( const Scalar & a,
const WR2 & b )

◆ operator>() [54/89]

WSR4 operator> ( const Scalar & a,
const WSR4 & b )

◆ operator>() [55/89]

WWR4 operator> ( const Scalar & a,
const WWR4 & b )

◆ operator>() [56/89]

SFFR4 operator> ( const SFFR4 & a,
const CScalar & b )

◆ operator>() [57/89]

SFFR4 operator> ( const SFFR4 & a,
const Scalar & b )

◆ operator>() [58/89]

SFFR4 operator> ( const SFFR4 & a,
const SFFR4 & b )

◆ operator>() [59/89]

SFR3 operator> ( const SFR3 & a,
const CScalar & b )

◆ operator>() [60/89]

SFR3 operator> ( const SFR3 & a,
const Scalar & b )

◆ operator>() [61/89]

SFR3 operator> ( const SFR3 & a,
const SFR3 & b )

◆ operator>() [62/89]

SR2 operator> ( const SR2 & a,
const CScalar & b )

◆ operator>() [63/89]

SR2 operator> ( const SR2 & a,
const Scalar & b )

◆ operator>() [64/89]

SR2 operator> ( const SR2 & a,
const SR2 & b )

◆ operator>() [65/89]

SSR4 operator> ( const SSR4 & a,
const CScalar & b )

◆ operator>() [66/89]

SSR4 operator> ( const SSR4 & a,
const Scalar & b )

◆ operator>() [67/89]

SSR4 operator> ( const SSR4 & a,
const SSR4 & b )

◆ operator>() [68/89]

SWR4 operator> ( const SWR4 & a,
const CScalar & b )

◆ operator>() [69/89]

SWR4 operator> ( const SWR4 & a,
const Scalar & b )

◆ operator>() [70/89]

SWR4 operator> ( const SWR4 & a,
const SWR4 & b )

◆ operator>() [71/89]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator> ( const T1 & a,
const T2 & b )

◆ operator>() [72/89]

Tensor operator> ( const Tensor & a,
const CScalar & b )

◆ operator>() [73/89]

Tensor operator> ( const Tensor & a,
const Scalar & b )

◆ operator>() [74/89]

Tensor operator> ( const Tensor & a,
const Tensor & b )

◆ operator>() [75/89]

Vec operator> ( const Vec & a,
const CScalar & b )

◆ operator>() [76/89]

Vec operator> ( const Vec & a,
const Scalar & b )

◆ operator>() [77/89]

Vec operator> ( const Vec & a,
const Vec & b )

◆ operator>() [78/89]

WFFR4 operator> ( const WFFR4 & a,
const CScalar & b )

◆ operator>() [79/89]

WFFR4 operator> ( const WFFR4 & a,
const Scalar & b )

◆ operator>() [80/89]

WFFR4 operator> ( const WFFR4 & a,
const WFFR4 & b )

◆ operator>() [81/89]

WR2 operator> ( const WR2 & a,
const CScalar & b )

◆ operator>() [82/89]

WR2 operator> ( const WR2 & a,
const Scalar & b )

◆ operator>() [83/89]

WR2 operator> ( const WR2 & a,
const WR2 & b )

◆ operator>() [84/89]

WSR4 operator> ( const WSR4 & a,
const CScalar & b )

◆ operator>() [85/89]

WSR4 operator> ( const WSR4 & a,
const Scalar & b )

◆ operator>() [86/89]

WSR4 operator> ( const WSR4 & a,
const WSR4 & b )

◆ operator>() [87/89]

WWR4 operator> ( const WWR4 & a,
const CScalar & b )

◆ operator>() [88/89]

WWR4 operator> ( const WWR4 & a,
const Scalar & b )

◆ operator>() [89/89]

WWR4 operator> ( const WWR4 & a,
const WWR4 & b )

◆ operator>=() [1/89]

MillerIndex operator>= ( const CScalar & a,
const MillerIndex & b )

◆ operator>=() [2/89]

Quaternion operator>= ( const CScalar & a,
const Quaternion & b )

◆ operator>=() [3/89]

R2 operator>= ( const CScalar & a,
const R2 & b )

◆ operator>=() [4/89]

R3 operator>= ( const CScalar & a,
const R3 & b )

◆ operator>=() [5/89]

R4 operator>= ( const CScalar & a,
const R4 & b )

◆ operator>=() [6/89]

Rot operator>= ( const CScalar & a,
const Rot & b )

◆ operator>=() [7/89]

Scalar operator>= ( const CScalar & a,
const Scalar & b )

◆ operator>=() [8/89]

SFFR4 operator>= ( const CScalar & a,
const SFFR4 & b )

◆ operator>=() [9/89]

SFR3 operator>= ( const CScalar & a,
const SFR3 & b )

◆ operator>=() [10/89]

SR2 operator>= ( const CScalar & a,
const SR2 & b )

◆ operator>=() [11/89]

SSR4 operator>= ( const CScalar & a,
const SSR4 & b )

◆ operator>=() [12/89]

SWR4 operator>= ( const CScalar & a,
const SWR4 & b )

◆ operator>=() [13/89]

Tensor operator>= ( const CScalar & a,
const Tensor & b )

◆ operator>=() [14/89]

Vec operator>= ( const CScalar & a,
const Vec & b )

◆ operator>=() [15/89]

WFFR4 operator>= ( const CScalar & a,
const WFFR4 & b )

◆ operator>=() [16/89]

WR2 operator>= ( const CScalar & a,
const WR2 & b )

◆ operator>=() [17/89]

WSR4 operator>= ( const CScalar & a,
const WSR4 & b )

◆ operator>=() [18/89]

WWR4 operator>= ( const CScalar & a,
const WWR4 & b )

◆ operator>=() [19/89]

MillerIndex operator>= ( const MillerIndex & a,
const CScalar & b )

◆ operator>=() [20/89]

MillerIndex operator>= ( const MillerIndex & a,
const MillerIndex & b )

◆ operator>=() [21/89]

MillerIndex operator>= ( const MillerIndex & a,
const Scalar & b )

◆ operator>=() [22/89]

Quaternion operator>= ( const Quaternion & a,
const CScalar & b )

◆ operator>=() [23/89]

Quaternion operator>= ( const Quaternion & a,
const Quaternion & b )

◆ operator>=() [24/89]

Quaternion operator>= ( const Quaternion & a,
const Scalar & b )

◆ operator>=() [25/89]

R2 operator>= ( const R2 & a,
const CScalar & b )

◆ operator>=() [26/89]

R2 operator>= ( const R2 & a,
const R2 & b )

◆ operator>=() [27/89]

R2 operator>= ( const R2 & a,
const Scalar & b )

◆ operator>=() [28/89]

R3 operator>= ( const R3 & a,
const CScalar & b )

◆ operator>=() [29/89]

R3 operator>= ( const R3 & a,
const R3 & b )

◆ operator>=() [30/89]

R3 operator>= ( const R3 & a,
const Scalar & b )

◆ operator>=() [31/89]

R4 operator>= ( const R4 & a,
const CScalar & b )

◆ operator>=() [32/89]

R4 operator>= ( const R4 & a,
const R4 & b )

◆ operator>=() [33/89]

R4 operator>= ( const R4 & a,
const Scalar & b )

◆ operator>=() [34/89]

Rot operator>= ( const Rot & a,
const CScalar & b )

◆ operator>=() [35/89]

Rot operator>= ( const Rot & a,
const Rot & b )

◆ operator>=() [36/89]

Rot operator>= ( const Rot & a,
const Scalar & b )

◆ operator>=() [37/89]

Scalar operator>= ( const Scalar & a,
const CScalar & b )

◆ operator>=() [38/89]

MillerIndex operator>= ( const Scalar & a,
const MillerIndex & b )

◆ operator>=() [39/89]

Quaternion operator>= ( const Scalar & a,
const Quaternion & b )

◆ operator>=() [40/89]

R2 operator>= ( const Scalar & a,
const R2 & b )

◆ operator>=() [41/89]

R3 operator>= ( const Scalar & a,
const R3 & b )

◆ operator>=() [42/89]

R4 operator>= ( const Scalar & a,
const R4 & b )

◆ operator>=() [43/89]

Rot operator>= ( const Scalar & a,
const Rot & b )

◆ operator>=() [44/89]

Scalar operator>= ( const Scalar & a,
const Scalar & b )

◆ operator>=() [45/89]

SFFR4 operator>= ( const Scalar & a,
const SFFR4 & b )

◆ operator>=() [46/89]

SFR3 operator>= ( const Scalar & a,
const SFR3 & b )

◆ operator>=() [47/89]

SR2 operator>= ( const Scalar & a,
const SR2 & b )

◆ operator>=() [48/89]

SSR4 operator>= ( const Scalar & a,
const SSR4 & b )

◆ operator>=() [49/89]

SWR4 operator>= ( const Scalar & a,
const SWR4 & b )

◆ operator>=() [50/89]

Tensor operator>= ( const Scalar & a,
const Tensor & b )

◆ operator>=() [51/89]

Vec operator>= ( const Scalar & a,
const Vec & b )

◆ operator>=() [52/89]

WFFR4 operator>= ( const Scalar & a,
const WFFR4 & b )

◆ operator>=() [53/89]

WR2 operator>= ( const Scalar & a,
const WR2 & b )

◆ operator>=() [54/89]

WSR4 operator>= ( const Scalar & a,
const WSR4 & b )

◆ operator>=() [55/89]

WWR4 operator>= ( const Scalar & a,
const WWR4 & b )

◆ operator>=() [56/89]

SFFR4 operator>= ( const SFFR4 & a,
const CScalar & b )

◆ operator>=() [57/89]

SFFR4 operator>= ( const SFFR4 & a,
const Scalar & b )

◆ operator>=() [58/89]

SFFR4 operator>= ( const SFFR4 & a,
const SFFR4 & b )

◆ operator>=() [59/89]

SFR3 operator>= ( const SFR3 & a,
const CScalar & b )

◆ operator>=() [60/89]

SFR3 operator>= ( const SFR3 & a,
const Scalar & b )

◆ operator>=() [61/89]

SFR3 operator>= ( const SFR3 & a,
const SFR3 & b )

◆ operator>=() [62/89]

SR2 operator>= ( const SR2 & a,
const CScalar & b )

◆ operator>=() [63/89]

SR2 operator>= ( const SR2 & a,
const Scalar & b )

◆ operator>=() [64/89]

SR2 operator>= ( const SR2 & a,
const SR2 & b )

◆ operator>=() [65/89]

SSR4 operator>= ( const SSR4 & a,
const CScalar & b )

◆ operator>=() [66/89]

SSR4 operator>= ( const SSR4 & a,
const Scalar & b )

◆ operator>=() [67/89]

SSR4 operator>= ( const SSR4 & a,
const SSR4 & b )

◆ operator>=() [68/89]

SWR4 operator>= ( const SWR4 & a,
const CScalar & b )

◆ operator>=() [69/89]

SWR4 operator>= ( const SWR4 & a,
const Scalar & b )

◆ operator>=() [70/89]

SWR4 operator>= ( const SWR4 & a,
const SWR4 & b )

◆ operator>=() [71/89]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator>= ( const T1 & a,
const T2 & b )

◆ operator>=() [72/89]

Tensor operator>= ( const Tensor & a,
const CScalar & b )

◆ operator>=() [73/89]

Tensor operator>= ( const Tensor & a,
const Scalar & b )

◆ operator>=() [74/89]

Tensor operator>= ( const Tensor & a,
const Tensor & b )

◆ operator>=() [75/89]

Vec operator>= ( const Vec & a,
const CScalar & b )

◆ operator>=() [76/89]

Vec operator>= ( const Vec & a,
const Scalar & b )

◆ operator>=() [77/89]

Vec operator>= ( const Vec & a,
const Vec & b )

◆ operator>=() [78/89]

WFFR4 operator>= ( const WFFR4 & a,
const CScalar & b )

◆ operator>=() [79/89]

WFFR4 operator>= ( const WFFR4 & a,
const Scalar & b )

◆ operator>=() [80/89]

WFFR4 operator>= ( const WFFR4 & a,
const WFFR4 & b )

◆ operator>=() [81/89]

WR2 operator>= ( const WR2 & a,
const CScalar & b )

◆ operator>=() [82/89]

WR2 operator>= ( const WR2 & a,
const Scalar & b )

◆ operator>=() [83/89]

WR2 operator>= ( const WR2 & a,
const WR2 & b )

◆ operator>=() [84/89]

WSR4 operator>= ( const WSR4 & a,
const CScalar & b )

◆ operator>=() [85/89]

WSR4 operator>= ( const WSR4 & a,
const Scalar & b )

◆ operator>=() [86/89]

WSR4 operator>= ( const WSR4 & a,
const WSR4 & b )

◆ operator>=() [87/89]

WWR4 operator>= ( const WWR4 & a,
const CScalar & b )

◆ operator>=() [88/89]

WWR4 operator>= ( const WWR4 & a,
const Scalar & b )

◆ operator>=() [89/89]

WWR4 operator>= ( const WWR4 & a,
const WWR4 & b )

◆ operator>>() [1/3]

std::stringstream & operator>> ( std::stringstream & ,
EnumSelection &  )

◆ operator>>() [2/3]

std::stringstream & operator>> ( std::stringstream & ,
MultiEnumSelection &  )

◆ operator>>() [3/3]

template<typename T>
std::stringstream & operator>> ( std::stringstream & ss,
TensorName< T > & t )

Stream into a TensorName (used by Parsers to extract input options).

◆ operator||() [1/89]

MillerIndex operator|| ( const CScalar & a,
const MillerIndex & b )

◆ operator||() [2/89]

Quaternion operator|| ( const CScalar & a,
const Quaternion & b )

◆ operator||() [3/89]

R2 operator|| ( const CScalar & a,
const R2 & b )

◆ operator||() [4/89]

R3 operator|| ( const CScalar & a,
const R3 & b )

◆ operator||() [5/89]

R4 operator|| ( const CScalar & a,
const R4 & b )

◆ operator||() [6/89]

Rot operator|| ( const CScalar & a,
const Rot & b )

◆ operator||() [7/89]

Scalar operator|| ( const CScalar & a,
const Scalar & b )

◆ operator||() [8/89]

SFFR4 operator|| ( const CScalar & a,
const SFFR4 & b )

◆ operator||() [9/89]

SFR3 operator|| ( const CScalar & a,
const SFR3 & b )

◆ operator||() [10/89]

SR2 operator|| ( const CScalar & a,
const SR2 & b )

◆ operator||() [11/89]

SSR4 operator|| ( const CScalar & a,
const SSR4 & b )

◆ operator||() [12/89]

SWR4 operator|| ( const CScalar & a,
const SWR4 & b )

◆ operator||() [13/89]

Tensor operator|| ( const CScalar & a,
const Tensor & b )

◆ operator||() [14/89]

Vec operator|| ( const CScalar & a,
const Vec & b )

◆ operator||() [15/89]

WFFR4 operator|| ( const CScalar & a,
const WFFR4 & b )

◆ operator||() [16/89]

WR2 operator|| ( const CScalar & a,
const WR2 & b )

◆ operator||() [17/89]

WSR4 operator|| ( const CScalar & a,
const WSR4 & b )

◆ operator||() [18/89]

WWR4 operator|| ( const CScalar & a,
const WWR4 & b )

◆ operator||() [19/89]

MillerIndex operator|| ( const MillerIndex & a,
const CScalar & b )

◆ operator||() [20/89]

MillerIndex operator|| ( const MillerIndex & a,
const MillerIndex & b )

◆ operator||() [21/89]

MillerIndex operator|| ( const MillerIndex & a,
const Scalar & b )

◆ operator||() [22/89]

Quaternion operator|| ( const Quaternion & a,
const CScalar & b )

◆ operator||() [23/89]

Quaternion operator|| ( const Quaternion & a,
const Quaternion & b )

◆ operator||() [24/89]

Quaternion operator|| ( const Quaternion & a,
const Scalar & b )

◆ operator||() [25/89]

R2 operator|| ( const R2 & a,
const CScalar & b )

◆ operator||() [26/89]

R2 operator|| ( const R2 & a,
const R2 & b )

◆ operator||() [27/89]

R2 operator|| ( const R2 & a,
const Scalar & b )

◆ operator||() [28/89]

R3 operator|| ( const R3 & a,
const CScalar & b )

◆ operator||() [29/89]

R3 operator|| ( const R3 & a,
const R3 & b )

◆ operator||() [30/89]

R3 operator|| ( const R3 & a,
const Scalar & b )

◆ operator||() [31/89]

R4 operator|| ( const R4 & a,
const CScalar & b )

◆ operator||() [32/89]

R4 operator|| ( const R4 & a,
const R4 & b )

◆ operator||() [33/89]

R4 operator|| ( const R4 & a,
const Scalar & b )

◆ operator||() [34/89]

Rot operator|| ( const Rot & a,
const CScalar & b )

◆ operator||() [35/89]

Rot operator|| ( const Rot & a,
const Rot & b )

◆ operator||() [36/89]

Rot operator|| ( const Rot & a,
const Scalar & b )

◆ operator||() [37/89]

Scalar operator|| ( const Scalar & a,
const CScalar & b )

◆ operator||() [38/89]

MillerIndex operator|| ( const Scalar & a,
const MillerIndex & b )

◆ operator||() [39/89]

Quaternion operator|| ( const Scalar & a,
const Quaternion & b )

◆ operator||() [40/89]

R2 operator|| ( const Scalar & a,
const R2 & b )

◆ operator||() [41/89]

R3 operator|| ( const Scalar & a,
const R3 & b )

◆ operator||() [42/89]

R4 operator|| ( const Scalar & a,
const R4 & b )

◆ operator||() [43/89]

Rot operator|| ( const Scalar & a,
const Rot & b )

◆ operator||() [44/89]

Scalar operator|| ( const Scalar & a,
const Scalar & b )

◆ operator||() [45/89]

SFFR4 operator|| ( const Scalar & a,
const SFFR4 & b )

◆ operator||() [46/89]

SFR3 operator|| ( const Scalar & a,
const SFR3 & b )

◆ operator||() [47/89]

SR2 operator|| ( const Scalar & a,
const SR2 & b )

◆ operator||() [48/89]

SSR4 operator|| ( const Scalar & a,
const SSR4 & b )

◆ operator||() [49/89]

SWR4 operator|| ( const Scalar & a,
const SWR4 & b )

◆ operator||() [50/89]

Tensor operator|| ( const Scalar & a,
const Tensor & b )

◆ operator||() [51/89]

Vec operator|| ( const Scalar & a,
const Vec & b )

◆ operator||() [52/89]

WFFR4 operator|| ( const Scalar & a,
const WFFR4 & b )

◆ operator||() [53/89]

WR2 operator|| ( const Scalar & a,
const WR2 & b )

◆ operator||() [54/89]

WSR4 operator|| ( const Scalar & a,
const WSR4 & b )

◆ operator||() [55/89]

WWR4 operator|| ( const Scalar & a,
const WWR4 & b )

◆ operator||() [56/89]

SFFR4 operator|| ( const SFFR4 & a,
const CScalar & b )

◆ operator||() [57/89]

SFFR4 operator|| ( const SFFR4 & a,
const Scalar & b )

◆ operator||() [58/89]

SFFR4 operator|| ( const SFFR4 & a,
const SFFR4 & b )

◆ operator||() [59/89]

SFR3 operator|| ( const SFR3 & a,
const CScalar & b )

◆ operator||() [60/89]

SFR3 operator|| ( const SFR3 & a,
const Scalar & b )

◆ operator||() [61/89]

SFR3 operator|| ( const SFR3 & a,
const SFR3 & b )

◆ operator||() [62/89]

SR2 operator|| ( const SR2 & a,
const CScalar & b )

◆ operator||() [63/89]

SR2 operator|| ( const SR2 & a,
const Scalar & b )

◆ operator||() [64/89]

SR2 operator|| ( const SR2 & a,
const SR2 & b )

◆ operator||() [65/89]

SSR4 operator|| ( const SSR4 & a,
const CScalar & b )

◆ operator||() [66/89]

SSR4 operator|| ( const SSR4 & a,
const Scalar & b )

◆ operator||() [67/89]

SSR4 operator|| ( const SSR4 & a,
const SSR4 & b )

◆ operator||() [68/89]

SWR4 operator|| ( const SWR4 & a,
const CScalar & b )

◆ operator||() [69/89]

SWR4 operator|| ( const SWR4 & a,
const Scalar & b )

◆ operator||() [70/89]

SWR4 operator|| ( const SWR4 & a,
const SWR4 & b )

◆ operator||() [71/89]

template<typename T1, typename T2, typename = typename std::enable_if_t<std::is_base_of_v<VariableBase, T1> || std::is_base_of_v<VariableBase, T2>>>
auto operator|| ( const T1 & a,
const T2 & b )

◆ operator||() [72/89]

Tensor operator|| ( const Tensor & a,
const CScalar & b )

◆ operator||() [73/89]

Tensor operator|| ( const Tensor & a,
const Scalar & b )

◆ operator||() [74/89]

Tensor operator|| ( const Tensor & a,
const Tensor & b )

◆ operator||() [75/89]

Vec operator|| ( const Vec & a,
const CScalar & b )

◆ operator||() [76/89]

Vec operator|| ( const Vec & a,
const Scalar & b )

◆ operator||() [77/89]

Vec operator|| ( const Vec & a,
const Vec & b )

◆ operator||() [78/89]

WFFR4 operator|| ( const WFFR4 & a,
const CScalar & b )

◆ operator||() [79/89]

WFFR4 operator|| ( const WFFR4 & a,
const Scalar & b )

◆ operator||() [80/89]

WFFR4 operator|| ( const WFFR4 & a,
const WFFR4 & b )

◆ operator||() [81/89]

WR2 operator|| ( const WR2 & a,
const CScalar & b )

◆ operator||() [82/89]

WR2 operator|| ( const WR2 & a,
const Scalar & b )

◆ operator||() [83/89]

WR2 operator|| ( const WR2 & a,
const WR2 & b )

◆ operator||() [84/89]

WSR4 operator|| ( const WSR4 & a,
const CScalar & b )

◆ operator||() [85/89]

WSR4 operator|| ( const WSR4 & a,
const Scalar & b )

◆ operator||() [86/89]

WSR4 operator|| ( const WSR4 & a,
const WSR4 & b )

◆ operator||() [87/89]

WWR4 operator|| ( const WWR4 & a,
const CScalar & b )

◆ operator||() [88/89]

WWR4 operator|| ( const WWR4 & a,
const Scalar & b )

◆ operator||() [89/89]

WWR4 operator|| ( const WWR4 & a,
const WWR4 & b )

◆ options_compatible()

bool options_compatible ( const OptionSet & opts,
const OptionSet & additional_opts )

◆ outer() [1/8]

R4 outer ( const R2 & )

◆ outer() [2/8]

R4 outer ( const R2 & ,
const R2 &  )

◆ outer() [3/8]

SSR4 outer ( const SR2 & )

◆ outer() [4/8]

SSR4 outer ( const SR2 & ,
const SR2 &  )

◆ outer() [5/8]

Tensor outer ( const Tensor & )

◆ outer() [6/8]

Tensor outer ( const Tensor & ,
const Tensor &  )

Outer product

◆ outer() [7/8]

R2 outer ( const Vec & )

◆ outer() [8/8]

R2 outer ( const Vec & ,
const Vec &  )

◆ parametric_coordinates()

std::tuple< Scalar, Scalar, Scalar > parametric_coordinates ( const Scalar & X,
const Scalar & x )

◆ pop_intrsc_intmd_dim() [1/3]

Tensor pop_intrsc_intmd_dim ( const Derivative< 1 > & deriv)

Move the trailing intrinsic intermediate dimensions to the base for a Derivative If the derivative has broadcasting intrinsic intermediate dimensions, this also handles fullification.

◆ pop_intrsc_intmd_dim() [2/3]

template<std::size_t N>
Tensor pop_intrsc_intmd_dim ( const Tensor & from,
const std::array< std::size_t, N > & intrsc_intmd_dims,
const std::array< TensorShape, N > & base_shapes,
const std::string & debug_name = "<anonymous>" )

Move the trailing intrinsic intermediate dimensions to the base for a Derivative of order

Template Parameters
N.This also handles permutation of variable and argument's intrinsic intermediate dimensions and base dimensions.

◆ pop_intrsc_intmd_dim() [3/3]

Tensor pop_intrsc_intmd_dim ( const Tensor & t,
Size dim )

Move the trailing dim intermediate dimensions to the base.

◆ pow() [1/39]

Scalar pow ( const CScalar & a,
const Scalar & n )

◆ pow() [2/39]

Tensor pow ( const CScalar & a,
const Tensor & n )

Element-wise pow.

◆ pow() [3/39]

MillerIndex pow ( const MillerIndex & a,
const CScalar & n )

◆ pow() [4/39]

MillerIndex pow ( const MillerIndex & a,
const Scalar & n )

◆ pow() [5/39]

Quaternion pow ( const Quaternion & a,
const CScalar & n )

◆ pow() [6/39]

Quaternion pow ( const Quaternion & a,
const Scalar & n )

◆ pow() [7/39]

R2 pow ( const R2 & a,
const CScalar & n )

◆ pow() [8/39]

R2 pow ( const R2 & a,
const Scalar & n )

◆ pow() [9/39]

R3 pow ( const R3 & a,
const CScalar & n )

◆ pow() [10/39]

R3 pow ( const R3 & a,
const Scalar & n )

◆ pow() [11/39]

R4 pow ( const R4 & a,
const CScalar & n )

◆ pow() [12/39]

R4 pow ( const R4 & a,
const Scalar & n )

◆ pow() [13/39]

Rot pow ( const Rot & a,
const CScalar & n )

◆ pow() [14/39]

Rot pow ( const Rot & a,
const Scalar & n )

◆ pow() [15/39]

Scalar pow ( const Scalar & a,
const CScalar & n )

◆ pow() [16/39]

Scalar pow ( const Scalar & a,
const Scalar & n )

◆ pow() [17/39]

SFFR4 pow ( const SFFR4 & a,
const CScalar & n )

◆ pow() [18/39]

SFFR4 pow ( const SFFR4 & a,
const Scalar & n )

◆ pow() [19/39]

SFR3 pow ( const SFR3 & a,
const CScalar & n )

◆ pow() [20/39]

SFR3 pow ( const SFR3 & a,
const Scalar & n )

◆ pow() [21/39]

SR2 pow ( const SR2 & a,
const CScalar & n )

◆ pow() [22/39]

SR2 pow ( const SR2 & a,
const Scalar & n )

◆ pow() [23/39]

SSR4 pow ( const SSR4 & a,
const CScalar & n )

◆ pow() [24/39]

SSR4 pow ( const SSR4 & a,
const Scalar & n )

◆ pow() [25/39]

SWR4 pow ( const SWR4 & a,
const CScalar & n )

◆ pow() [26/39]

SWR4 pow ( const SWR4 & a,
const Scalar & n )

◆ pow() [27/39]

Tensor pow ( const Tensor & a,
const CScalar & n )

◆ pow() [28/39]

Tensor pow ( const Tensor & a,
const Scalar & n )

◆ pow() [29/39]

Tensor pow ( const Tensor & a,
const Tensor & n )

Element-wise pow.

◆ pow() [30/39]

Vec pow ( const Vec & a,
const CScalar & n )

◆ pow() [31/39]

Vec pow ( const Vec & a,
const Scalar & n )

◆ pow() [32/39]

WFFR4 pow ( const WFFR4 & a,
const CScalar & n )

◆ pow() [33/39]

WFFR4 pow ( const WFFR4 & a,
const Scalar & n )

◆ pow() [34/39]

WR2 pow ( const WR2 & a,
const CScalar & n )

◆ pow() [35/39]

WR2 pow ( const WR2 & a,
const Scalar & n )

◆ pow() [36/39]

WSR4 pow ( const WSR4 & a,
const CScalar & n )

◆ pow() [37/39]

WSR4 pow ( const WSR4 & a,
const Scalar & n )

◆ pow() [38/39]

WWR4 pow ( const WWR4 & a,
const CScalar & n )

◆ pow() [39/39]

WWR4 pow ( const WWR4 & a,
const Scalar & n )

◆ proper_rotation_transform()

R2 proper_rotation_transform ( const Rot & rot)

A proper rotation, here provided by a Rot object.

◆ push_intrsc_intmd_dim() [1/2]

template<std::size_t N>
Tensor push_intrsc_intmd_dim ( const Tensor & from,
const std::array< std::size_t, N > & intrsc_intmd_dims,
const std::array< TensorShape, N > & base_shapes,
const std::string & debug_name = "<anonymous>" )

Move the leading base dimensions to intermediate dimensions for a Derivative of order

Template Parameters
N.This also handles permutation of variable and argument's intermediate dimensions and base dimensions.

◆ push_intrsc_intmd_dim() [2/2]

Tensor push_intrsc_intmd_dim ( const Tensor & t,
Size dim )

Move the leading dim base dimensions to intermediate dimensions.

◆ reflection_transform()

R2 reflection_transform ( const Vec & v)

A reflection, defined by the reflection plane.

◆ reserved_subaxis_names()

std::vector< std::string > reserved_subaxis_names ( )

◆ set_default_dtype()

void set_default_dtype ( Dtype dtype)

Set default dtype

◆ set_default_integer_dtype()

void set_default_integer_dtype ( Dtype dtype)

Set default integer dtype.

◆ sign() [1/18]

MillerIndex sign ( const MillerIndex & a)

◆ sign() [2/18]

Quaternion sign ( const Quaternion & a)

◆ sign() [3/18]

R2 sign ( const R2 & a)

◆ sign() [4/18]

R3 sign ( const R3 & a)

◆ sign() [5/18]

R4 sign ( const R4 & a)

◆ sign() [6/18]

Rot sign ( const Rot & a)

◆ sign() [7/18]

Scalar sign ( const Scalar & a)

◆ sign() [8/18]

SFFR4 sign ( const SFFR4 & a)

◆ sign() [9/18]

SFR3 sign ( const SFR3 & a)

◆ sign() [10/18]

SR2 sign ( const SR2 & a)

◆ sign() [11/18]

SSR4 sign ( const SSR4 & a)

◆ sign() [12/18]

SWR4 sign ( const SWR4 & a)

◆ sign() [13/18]

Tensor sign ( const Tensor & a)

◆ sign() [14/18]

Vec sign ( const Vec & a)

◆ sign() [15/18]

WFFR4 sign ( const WFFR4 & a)

◆ sign() [16/18]

WR2 sign ( const WR2 & a)

◆ sign() [17/18]

WSR4 sign ( const WSR4 & a)

◆ sign() [18/18]

WWR4 sign ( const WWR4 & a)

◆ sin() [1/18]

MillerIndex sin ( const MillerIndex & a)

◆ sin() [2/18]

Quaternion sin ( const Quaternion & a)

◆ sin() [3/18]

R2 sin ( const R2 & a)

◆ sin() [4/18]

R3 sin ( const R3 & a)

◆ sin() [5/18]

R4 sin ( const R4 & a)

◆ sin() [6/18]

Rot sin ( const Rot & a)

◆ sin() [7/18]

Scalar sin ( const Scalar & a)

◆ sin() [8/18]

SFFR4 sin ( const SFFR4 & a)

◆ sin() [9/18]

SFR3 sin ( const SFR3 & a)

◆ sin() [10/18]

SR2 sin ( const SR2 & a)

◆ sin() [11/18]

SSR4 sin ( const SSR4 & a)

◆ sin() [12/18]

SWR4 sin ( const SWR4 & a)

◆ sin() [13/18]

Tensor sin ( const Tensor & a)

◆ sin() [14/18]

Vec sin ( const Vec & a)

◆ sin() [15/18]

WFFR4 sin ( const WFFR4 & a)

◆ sin() [16/18]

WR2 sin ( const WR2 & a)

◆ sin() [17/18]

WSR4 sin ( const WSR4 & a)

◆ sin() [18/18]

WWR4 sin ( const WWR4 & a)

◆ sinh() [1/18]

MillerIndex sinh ( const MillerIndex & a)

◆ sinh() [2/18]

Quaternion sinh ( const Quaternion & a)

◆ sinh() [3/18]

R2 sinh ( const R2 & a)

◆ sinh() [4/18]

R3 sinh ( const R3 & a)

◆ sinh() [5/18]

R4 sinh ( const R4 & a)

◆ sinh() [6/18]

Rot sinh ( const Rot & a)

◆ sinh() [7/18]

Scalar sinh ( const Scalar & a)

◆ sinh() [8/18]

SFFR4 sinh ( const SFFR4 & a)

◆ sinh() [9/18]

SFR3 sinh ( const SFR3 & a)

◆ sinh() [10/18]

SR2 sinh ( const SR2 & a)

◆ sinh() [11/18]

SSR4 sinh ( const SSR4 & a)

◆ sinh() [12/18]

SWR4 sinh ( const SWR4 & a)

◆ sinh() [13/18]

Tensor sinh ( const Tensor & a)

◆ sinh() [14/18]

Vec sinh ( const Vec & a)

◆ sinh() [15/18]

WFFR4 sinh ( const WFFR4 & a)

◆ sinh() [16/18]

WR2 sinh ( const WR2 & a)

◆ sinh() [17/18]

WSR4 sinh ( const WSR4 & a)

◆ sinh() [18/18]

WWR4 sinh ( const WWR4 & a)

◆ skew_to_full()

Tensor skew_to_full ( const Tensor & skew,
Size dim = 0 )

Convert a Tensor from skew vector notation to full notation.

See full_to_skew for a detailed explanation.

Parameters
skewThe input tensor in skew notation
dimThe base dimension where the symmetric axes start
Returns
Tensor The resulting tensor in full notation.

◆ sqrt() [1/18]

MillerIndex sqrt ( const MillerIndex & a)

◆ sqrt() [2/18]

Quaternion sqrt ( const Quaternion & a)

◆ sqrt() [3/18]

R2 sqrt ( const R2 & a)

◆ sqrt() [4/18]

R3 sqrt ( const R3 & a)

◆ sqrt() [5/18]

R4 sqrt ( const R4 & a)

◆ sqrt() [6/18]

Rot sqrt ( const Rot & a)

◆ sqrt() [7/18]

Scalar sqrt ( const Scalar & a)

◆ sqrt() [8/18]

SFFR4 sqrt ( const SFFR4 & a)

◆ sqrt() [9/18]

SFR3 sqrt ( const SFR3 & a)

◆ sqrt() [10/18]

SR2 sqrt ( const SR2 & a)

◆ sqrt() [11/18]

SSR4 sqrt ( const SSR4 & a)

◆ sqrt() [12/18]

SWR4 sqrt ( const SWR4 & a)

◆ sqrt() [13/18]

Tensor sqrt ( const Tensor & a)

◆ sqrt() [14/18]

Vec sqrt ( const Vec & a)

◆ sqrt() [15/18]

WFFR4 sqrt ( const WFFR4 & a)

◆ sqrt() [16/18]

WR2 sqrt ( const WR2 & a)

◆ sqrt() [17/18]

WSR4 sqrt ( const WSR4 & a)

◆ sqrt() [18/18]

WWR4 sqrt ( const WWR4 & a)

◆ tan() [1/18]

MillerIndex tan ( const MillerIndex & a)

◆ tan() [2/18]

Quaternion tan ( const Quaternion & a)

◆ tan() [3/18]

R2 tan ( const R2 & a)

◆ tan() [4/18]

R3 tan ( const R3 & a)

◆ tan() [5/18]

R4 tan ( const R4 & a)

◆ tan() [6/18]

Rot tan ( const Rot & a)

◆ tan() [7/18]

Scalar tan ( const Scalar & a)

◆ tan() [8/18]

SFFR4 tan ( const SFFR4 & a)

◆ tan() [9/18]

SFR3 tan ( const SFR3 & a)

◆ tan() [10/18]

SR2 tan ( const SR2 & a)

◆ tan() [11/18]

SSR4 tan ( const SSR4 & a)

◆ tan() [12/18]

SWR4 tan ( const SWR4 & a)

◆ tan() [13/18]

Tensor tan ( const Tensor & a)

◆ tan() [14/18]

Vec tan ( const Vec & a)

◆ tan() [15/18]

WFFR4 tan ( const WFFR4 & a)

◆ tan() [16/18]

WR2 tan ( const WR2 & a)

◆ tan() [17/18]

WSR4 tan ( const WSR4 & a)

◆ tan() [18/18]

WWR4 tan ( const WWR4 & a)

◆ tanh() [1/18]

MillerIndex tanh ( const MillerIndex & a)

◆ tanh() [2/18]

Quaternion tanh ( const Quaternion & a)

◆ tanh() [3/18]

R2 tanh ( const R2 & a)

◆ tanh() [4/18]

R3 tanh ( const R3 & a)

◆ tanh() [5/18]

R4 tanh ( const R4 & a)

◆ tanh() [6/18]

Rot tanh ( const Rot & a)

◆ tanh() [7/18]

Scalar tanh ( const Scalar & a)

◆ tanh() [8/18]

SFFR4 tanh ( const SFFR4 & a)

◆ tanh() [9/18]

SFR3 tanh ( const SFR3 & a)

◆ tanh() [10/18]

SR2 tanh ( const SR2 & a)

◆ tanh() [11/18]

SSR4 tanh ( const SSR4 & a)

◆ tanh() [12/18]

SWR4 tanh ( const SWR4 & a)

◆ tanh() [13/18]

Tensor tanh ( const Tensor & a)

◆ tanh() [14/18]

Vec tanh ( const Vec & a)

◆ tanh() [15/18]

WFFR4 tanh ( const WFFR4 & a)

◆ tanh() [16/18]

WR2 tanh ( const WR2 & a)

◆ tanh() [17/18]

WSR4 tanh ( const WSR4 & a)

◆ tanh() [18/18]

WWR4 tanh ( const WWR4 & a)

◆ timed_sections()

std::map< std::string, std::map< std::string, unsigned long > > & timed_sections ( )

◆ to_assembly()

template<std::size_t N>
Tensor to_assembly ( const Tensor & from,
const std::array< TensorShape, N > & intmd_shapes,
const std::array< TensorShape, N > & base_shapes )

Convert a tensor from the normal format to the assembly format.

◆ tr() [1/4]

Scalar tr ( const R2 & )

◆ tr() [2/4]

Scalar tr ( const SR2 & )

◆ tr() [3/4]

Scalar tr ( const Tensor & )

Trace of a second order tensor

◆ tr() [4/4]

Scalar tr ( const WR2 & )

◆ transform_from_quaternion()

R2 transform_from_quaternion ( const Quaternion & q)

Construct from quaternions, useful for comparison to old NEML.

◆ unit() [1/18]

MillerIndex unit ( const MillerIndex & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [2/18]

Quaternion unit ( const Quaternion & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [3/18]

R2 unit ( const R2 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [4/18]

R3 unit ( const R3 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [5/18]

R4 unit ( const R4 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [6/18]

Rot unit ( const Rot & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [7/18]

Scalar unit ( const Scalar & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [8/18]

SFFR4 unit ( const SFFR4 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [9/18]

SFR3 unit ( const SFR3 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [10/18]

SR2 unit ( const SR2 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [11/18]

SSR4 unit ( const SSR4 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [12/18]

SWR4 unit ( const SWR4 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [13/18]

Tensor unit ( const Tensor & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [14/18]

Vec unit ( const Vec & a,
const std::optional< CScalar > & eps = std::nullopt )

Normalize a tensor by its Frobenius norm

◆ unit() [15/18]

WFFR4 unit ( const WFFR4 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [16/18]

WR2 unit ( const WR2 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [17/18]

WSR4 unit ( const WSR4 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ unit() [18/18]

WWR4 unit ( const WWR4 & a,
const std::optional< CScalar > & eps = std::nullopt )

◆ valuemap_cat_reduce()

ValueMap valuemap_cat_reduce ( const std::vector< ValueMap > & results,
Size dynamic_dim )

Concatenate the tensors in the ValueMap along the batch dimension.

Parameters
resultsThe results to concatenate
dynamic_dimThe dynamic dimension along which to concatenate
Returns
ValueMap with the tensors concatenated along the dynamic dimension

◆ valuemap_move_device()

ValueMap valuemap_move_device ( ValueMap && x,
Device device )

Move all tensors in a ValueMap to a device.

Parameters
xinput ValueMap
devicetarget device
Returns
ValueMap with all tensors moved

◆ valuemap_no_operation()

ValueMap valuemap_no_operation ( ValueMap && x)

No operation.

◆ vdot()

Scalar vdot ( const Tensor & u,
const Tensor & v )

Vector-vector dot product.

◆ vol() [1/4]

R2 vol ( const R2 & )

◆ vol() [2/4]

SR2 vol ( const SR2 & )

◆ vol() [3/4]

Tensor vol ( const Tensor & )

Volumetric part of a second order tensor

◆ vol() [4/4]

WR2 vol ( const WR2 & )

◆ where() [1/36]

MillerIndex where ( const Scalar & c,
const MillerIndex & a,
const MillerIndex & b )

◆ where() [2/36]

Quaternion where ( const Scalar & c,
const Quaternion & a,
const Quaternion & b )

◆ where() [3/36]

R2 where ( const Scalar & c,
const R2 & a,
const R2 & b )

◆ where() [4/36]

R3 where ( const Scalar & c,
const R3 & a,
const R3 & b )

◆ where() [5/36]

R4 where ( const Scalar & c,
const R4 & a,
const R4 & b )

◆ where() [6/36]

Rot where ( const Scalar & c,
const Rot & a,
const Rot & b )

◆ where() [7/36]

Scalar where ( const Scalar & c,
const Scalar & a,
const Scalar & b )

◆ where() [8/36]

SFFR4 where ( const Scalar & c,
const SFFR4 & a,
const SFFR4 & b )

◆ where() [9/36]

SFR3 where ( const Scalar & c,
const SFR3 & a,
const SFR3 & b )

◆ where() [10/36]

SR2 where ( const Scalar & c,
const SR2 & a,
const SR2 & b )

◆ where() [11/36]

SSR4 where ( const Scalar & c,
const SSR4 & a,
const SSR4 & b )

◆ where() [12/36]

SWR4 where ( const Scalar & c,
const SWR4 & a,
const SWR4 & b )

◆ where() [13/36]

Tensor where ( const Scalar & c,
const Tensor & a,
const Tensor & b )

◆ where() [14/36]

Vec where ( const Scalar & c,
const Vec & a,
const Vec & b )

◆ where() [15/36]

WFFR4 where ( const Scalar & c,
const WFFR4 & a,
const WFFR4 & b )

◆ where() [16/36]

WR2 where ( const Scalar & c,
const WR2 & a,
const WR2 & b )

◆ where() [17/36]

WSR4 where ( const Scalar & c,
const WSR4 & a,
const WSR4 & b )

◆ where() [18/36]

WWR4 where ( const Scalar & c,
const WWR4 & a,
const WWR4 & b )

◆ where() [19/36]

MillerIndex where ( const Tensor & c,
const MillerIndex & a,
const MillerIndex & b )

◆ where() [20/36]

Quaternion where ( const Tensor & c,
const Quaternion & a,
const Quaternion & b )

◆ where() [21/36]

R2 where ( const Tensor & c,
const R2 & a,
const R2 & b )

◆ where() [22/36]

R3 where ( const Tensor & c,
const R3 & a,
const R3 & b )

◆ where() [23/36]

R4 where ( const Tensor & c,
const R4 & a,
const R4 & b )

◆ where() [24/36]

Rot where ( const Tensor & c,
const Rot & a,
const Rot & b )

◆ where() [25/36]

Scalar where ( const Tensor & c,
const Scalar & a,
const Scalar & b )

◆ where() [26/36]

SFFR4 where ( const Tensor & c,
const SFFR4 & a,
const SFFR4 & b )

◆ where() [27/36]

SFR3 where ( const Tensor & c,
const SFR3 & a,
const SFR3 & b )

◆ where() [28/36]

SR2 where ( const Tensor & c,
const SR2 & a,
const SR2 & b )

◆ where() [29/36]

SSR4 where ( const Tensor & c,
const SSR4 & a,
const SSR4 & b )

◆ where() [30/36]

SWR4 where ( const Tensor & c,
const SWR4 & a,
const SWR4 & b )

◆ where() [31/36]

Tensor where ( const Tensor & c,
const Tensor & a,
const Tensor & b )

◆ where() [32/36]

Vec where ( const Tensor & c,
const Vec & a,
const Vec & b )

◆ where() [33/36]

WFFR4 where ( const Tensor & c,
const WFFR4 & a,
const WFFR4 & b )

◆ where() [34/36]

WR2 where ( const Tensor & c,
const WR2 & a,
const WR2 & b )

◆ where() [35/36]

WSR4 where ( const Tensor & c,
const WSR4 & a,
const WSR4 & b )

◆ where() [36/36]

WWR4 where ( const Tensor & c,
const WWR4 & a,
const WWR4 & b )

Variable Documentation

◆ eps

auto eps = std::numeric_limits<double>::epsilon()
constexpr

Constants.

◆ FORCES

const std::string FORCES = "forces"
inline

◆ invsqrt2

double invsqrt2 = 0.7071067811865475
constexpr

◆ kCPU

auto kCPU = c10::DeviceType::CPU
constexpr

◆ kCUDA

auto kCUDA = c10::DeviceType::CUDA
constexpr

◆ kFloat16

auto kFloat16 = c10::kHalf
constexpr

◆ kFloat32

auto kFloat32 = c10::kFloat
constexpr

◆ kFloat64

auto kFloat64 = c10::kDouble
constexpr

◆ kInt16

auto kInt16 = c10::kShort
constexpr

◆ kInt32

auto kInt32 = c10::kInt
constexpr

◆ kInt64

auto kInt64 = c10::kLong
constexpr

◆ kInt8

auto kInt8 = c10::kChar
constexpr

Fixed width dtypes (mirroring the definition in <torch/csrc/api/include/torch/types.h>).

◆ mandel_index

std::array<std::array<Size, 2>, 6> mandel_index
constexpr
Initial value:
{std::array<Size, 2>{0, 0},
std::array<Size, 2>{1, 1},
std::array<Size, 2>{2, 2},
std::array<Size, 2>{1, 2},
std::array<Size, 2>{0, 2},
std::array<Size, 2>{0, 1}}

◆ mandel_reverse_index

std::array<std::array<Size, 3>, 3> mandel_reverse_index
constexpr
Initial value:
{
std::array<Size, 3>{0, 5, 4}, std::array<Size, 3>{5, 1, 3}, std::array<Size, 3>{4, 3, 2}}

◆ OLD_FORCES

const std::string OLD_FORCES = "old_forces"
inline

◆ OLD_STATE

const std::string OLD_STATE = "old_state"
inline

◆ PARAMETERS

const std::string PARAMETERS = "parameters"
inline

◆ pi

double pi = M_PI
constexpr

◆ RESIDUAL

const std::string RESIDUAL = "residual"
inline

◆ skew_factor

std::array<std::array<double, 3>, 3> skew_factor
constexpr
Initial value:
{std::array<double, 3>{0.0, -1.0, 1.0},
std::array<double, 3>{1.0, 0.0, -1.0},
std::array<double, 3>{-1.0, 1.0, 0.0}}

◆ skew_reverse_index

std::array<std::array<Size, 3>, 3> skew_reverse_index
constexpr
Initial value:
{
std::array<Size, 3>{0, 2, 1}, std::array<Size, 3>{2, 0, 0}, std::array<Size, 3>{1, 0, 0}}

◆ sqrt2

double sqrt2 = 1.4142135623730951
constexpr

◆ STATE

const std::string STATE = "state"
inline